SystemZISelLowering.cpp revision 6824f127f90197b26af93cf5d6c13b7941567e54
11d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===-- SystemZISelLowering.cpp - SystemZ DAG lowering implementation -----===// 21d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// 31d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// The LLVM Compiler Infrastructure 41d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// 51d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// This file is distributed under the University of Illinois Open Source 61d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// License. See LICENSE.TXT for details. 71d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// 81d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 91d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// 101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// This file implements the SystemZTargetLowering class. 111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// 121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#define DEBUG_TYPE "systemz-lower" 151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "SystemZISelLowering.h" 171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "SystemZCallingConv.h" 181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "SystemZConstantPoolValue.h" 191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "SystemZMachineFunctionInfo.h" 201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "SystemZTargetMachine.h" 211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "llvm/CodeGen/CallingConvLower.h" 221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "llvm/CodeGen/MachineInstrBuilder.h" 231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "llvm/CodeGen/MachineRegisterInfo.h" 241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" 251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandusing namespace llvm; 271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Classify VT as either 32 or 64 bit. 291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic bool is32Bit(EVT VT) { 301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (VT.getSimpleVT().SimpleTy) { 311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case MVT::i32: 321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return true; 331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case MVT::i64: 341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return false; 351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Unsupported type"); 371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Return a version of MachineOperand that can be safely used before the 411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// final use. 421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic MachineOperand earlyUseOperand(MachineOperand Op) { 431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Op.isReg()) 441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.setIsKill(false); 451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Op; 461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::SystemZTargetLowering(SystemZTargetMachine &tm) 491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand : TargetLowering(tm, new TargetLoweringObjectFileELF()), 501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Subtarget(*tm.getSubtargetImpl()), TM(tm) { 511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT PtrVT = getPointerTy(); 521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Set up the register classes. 541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand addRegisterClass(MVT::i32, &SystemZ::GR32BitRegClass); 551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand addRegisterClass(MVT::i64, &SystemZ::GR64BitRegClass); 561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand addRegisterClass(MVT::f32, &SystemZ::FP32BitRegClass); 571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand addRegisterClass(MVT::f64, &SystemZ::FP64BitRegClass); 581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand addRegisterClass(MVT::f128, &SystemZ::FP128BitRegClass); 591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Compute derived properties from the register classes 611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand computeRegisterProperties(); 621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Set up special registers. 641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setExceptionPointerRegister(SystemZ::R6D); 651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setExceptionSelectorRegister(SystemZ::R7D); 661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setStackPointerRegisterToSaveRestore(SystemZ::R15D); 671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // TODO: It may be better to default to latency-oriented scheduling, however 691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // LLVM's current latency-oriented scheduler can't handle physreg definitions 70dbd8eb26ce1e7de9b69f5c46f45ba011a706c9b9Richard Sandiford // such as SystemZ has with CC, so set this to the register-pressure 711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // scheduler, because it can. 721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setSchedulingPreference(Sched::RegPressure); 731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setBooleanContents(ZeroOrOneBooleanContent); 751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setBooleanVectorContents(ZeroOrOneBooleanContent); // FIXME: Is this correct? 761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Instructions are strings of 2-byte aligned 2-byte values. 781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setMinFunctionAlignment(2); 791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Handle operations that are handled in a similar way for all types. 811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = MVT::FIRST_INTEGER_VALUETYPE; 821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand I <= MVT::LAST_FP_VALUETYPE; 831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ++I) { 841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT VT = MVT::SimpleValueType(I); 851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isTypeLegal(VT)) { 861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Expand SETCC(X, Y, COND) into SELECT_CC(X, Y, 1, 0, COND). 871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SETCC, VT, Expand); 881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Expand SELECT(C, A, B) into SELECT_CC(X, 0, A, B, NE). 901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SELECT, VT, Expand); 911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Lower SELECT_CC and BR_CC into separate comparisons and branches. 931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SELECT_CC, VT, Custom); 941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::BR_CC, VT, Custom); 951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Expand jump table branches as address arithmetic followed by an 991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // indirect jump. 1001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::BR_JT, MVT::Other, Expand); 1011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Expand BRCOND into a BR_CC (see above). 1031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::BRCOND, MVT::Other, Expand); 1041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Handle integer types. 1061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = MVT::FIRST_INTEGER_VALUETYPE; 1071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand I <= MVT::LAST_INTEGER_VALUETYPE; 1081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ++I) { 1091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT VT = MVT::SimpleValueType(I); 1101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isTypeLegal(VT)) { 1111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Expand individual DIV and REMs into DIVREMs. 1121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SDIV, VT, Expand); 1131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UDIV, VT, Expand); 1141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SREM, VT, Expand); 1151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UREM, VT, Expand); 1161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SDIVREM, VT, Custom); 1171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UDIVREM, VT, Custom); 1181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Expand ATOMIC_LOAD and ATOMIC_STORE using ATOMIC_CMP_SWAP. 1201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // FIXME: probably much too conservative. 1211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD, VT, Expand); 1221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_STORE, VT, Expand); 1231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // No special instructions for these. 1251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::CTPOP, VT, Expand); 1261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::CTTZ, VT, Expand); 1271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::CTTZ_ZERO_UNDEF, VT, Expand); 1281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::CTLZ_ZERO_UNDEF, VT, Expand); 1291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ROTR, VT, Expand); 1301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use *MUL_LOHI where possible and a wider multiplication otherwise. 1321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::MULHS, VT, Expand); 1331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::MULHU, VT, Expand); 1341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have instructions for signed but not unsigned FP conversion. 1361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FP_TO_UINT, VT, Expand); 1371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 1381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 1391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Type legalization will convert 8- and 16-bit atomic operations into 1411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // forms that operate on i32s (but still keeping the original memory VT). 1421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Lower them into full i32 operations. 1431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_SWAP, MVT::i32, Custom); 1441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_ADD, MVT::i32, Custom); 1451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_SUB, MVT::i32, Custom); 1461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_AND, MVT::i32, Custom); 1471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_OR, MVT::i32, Custom); 1481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_XOR, MVT::i32, Custom); 1491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_NAND, MVT::i32, Custom); 1501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_MIN, MVT::i32, Custom); 1511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_MAX, MVT::i32, Custom); 1521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_UMIN, MVT::i32, Custom); 1531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_LOAD_UMAX, MVT::i32, Custom); 1541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ATOMIC_CMP_SWAP, MVT::i32, Custom); 1551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have instructions for signed but not unsigned FP conversion. 1571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Handle unsigned 32-bit types as signed 64-bit types. 1581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UINT_TO_FP, MVT::i32, Promote); 1591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UINT_TO_FP, MVT::i64, Expand); 1601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have native support for a 64-bit CTLZ, via FLOGR. 1621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::CTLZ, MVT::i32, Promote); 1631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::CTLZ, MVT::i64, Legal); 1641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Give LowerOperation the chance to replace 64-bit ORs with subregs. 1661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::OR, MVT::i64, Custom); 1671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The architecture has 32-bit SMUL_LOHI and UMUL_LOHI (MR and MLR), 1691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // but they aren't really worth using. There is no 64-bit SMUL_LOHI, 1701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // but there is a 64-bit UMUL_LOHI: MLGR. 1711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SMUL_LOHI, MVT::i32, Expand); 1721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SMUL_LOHI, MVT::i64, Expand); 1731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UMUL_LOHI, MVT::i32, Expand); 1741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::UMUL_LOHI, MVT::i64, Custom); 1751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // FIXME: Can we support these natively? 1771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SRL_PARTS, MVT::i64, Expand); 1781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SHL_PARTS, MVT::i64, Expand); 1791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SRA_PARTS, MVT::i64, Expand); 1801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have native instructions for i8, i16 and i32 extensions, but not i1. 1821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setLoadExtAction(ISD::SEXTLOAD, MVT::i1, Promote); 1831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setLoadExtAction(ISD::ZEXTLOAD, MVT::i1, Promote); 1841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setLoadExtAction(ISD::EXTLOAD, MVT::i1, Promote); 1851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::SIGN_EXTEND_INREG, MVT::i1, Expand); 1861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Handle the various types of symbolic address. 1881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::ConstantPool, PtrVT, Custom); 1891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::GlobalAddress, PtrVT, Custom); 1901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::GlobalTLSAddress, PtrVT, Custom); 1911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::BlockAddress, PtrVT, Custom); 1921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::JumpTable, PtrVT, Custom); 1931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We need to handle dynamic allocations specially because of the 1951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // 160-byte area at the bottom of the stack. 1961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::DYNAMIC_STACKALLOC, PtrVT, Custom); 1971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use custom expanders so that we can force the function to use 1991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // a frame pointer. 2001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::STACKSAVE, MVT::Other, Custom); 2011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::STACKRESTORE, MVT::Other, Custom); 2021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Handle floating-point types. 2041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = MVT::FIRST_FP_VALUETYPE; 2051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand I <= MVT::LAST_FP_VALUETYPE; 2061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ++I) { 2071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT VT = MVT::SimpleValueType(I); 2081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isTypeLegal(VT)) { 2091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We can use FI for FRINT. 2101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FRINT, VT, Legal); 2111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // No special instructions for these. 2131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FSIN, VT, Expand); 2141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FCOS, VT, Expand); 2151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FREM, VT, Expand); 2161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 2171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 2181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have fused multiply-addition for f32 and f64 but not f128. 2201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FMA, MVT::f32, Legal); 2211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FMA, MVT::f64, Legal); 2221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::FMA, MVT::f128, Expand); 2231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Needed so that we don't try to implement f128 constant loads using 2251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // a load-and-extend of a f80 constant (in cases where the constant 2261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // would fit in an f80). 2271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setLoadExtAction(ISD::EXTLOAD, MVT::f80, Expand); 2281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Floating-point truncation and stores need to be done separately. 2301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setTruncStoreAction(MVT::f64, MVT::f32, Expand); 2311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setTruncStoreAction(MVT::f128, MVT::f32, Expand); 2321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setTruncStoreAction(MVT::f128, MVT::f64, Expand); 2331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have 64-bit FPR<->GPR moves, but need special handling for 2351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // 32-bit forms. 2361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::BITCAST, MVT::i32, Custom); 2371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::BITCAST, MVT::f32, Custom); 2381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // VASTART and VACOPY need to deal with the SystemZ-specific varargs 2401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // structure, but VAEND is a no-op. 2411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::VASTART, MVT::Other, Custom); 2421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::VACOPY, MVT::Other, Custom); 2431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand setOperationAction(ISD::VAEND, MVT::Other, Expand); 244dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford 245dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford // We want to use MVC in preference to even a single load/store pair. 246dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford MaxStoresPerMemcpy = 0; 247dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford MaxStoresPerMemcpyOptSize = 0; 248f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford 249f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford // The main memset sequence is a byte store followed by an MVC. 250f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford // Two STC or MV..I stores win over that, but the kind of fused stores 251f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford // generated by target-independent code don't when the byte value is 252f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford // variable. E.g. "STC <reg>;MHI <reg>,257;STH <reg>" is not better 253f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford // than "STC;MVC". Handle the choice in target-specific code instead. 254f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford MaxStoresPerMemset = 0; 255f6ea5e0d8007234fc74c1ff6ac2c3ca316c41d92Richard Sandiford MaxStoresPerMemsetOptSize = 0; 2561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 2571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 258e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Linbool 259e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen LinSystemZTargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const { 260e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin VT = VT.getScalarType(); 261e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin 262e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin if (!VT.isSimple()) 263e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin return false; 264e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin 265e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin switch (VT.getSimpleVT().SimpleTy) { 266e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin case MVT::f32: 267e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin case MVT::f64: 268e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin return true; 269e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin case MVT::f128: 270e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin return false; 271e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin default: 272e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin break; 273e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin } 274e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin 275e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin return false; 276e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin} 277e54885af9b54bfc7436a928a48d3db1ef88a2a70Stephen Lin 2781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandbool SystemZTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { 2791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We can load zero using LZ?R and negative zero using LZ?R;LC?BR. 2801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Imm.isZero() || Imm.isNegZero(); 2811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 2821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 28314a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandifordbool SystemZTargetLowering::allowsUnalignedMemoryAccesses(EVT VT, 28414a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford bool *Fast) const { 28514a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford // Unaligned accesses should never be slower than the expanded version. 28614a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford // We check specifically for aligned accesses in the few cases where 28714a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford // they are required. 28814a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford if (Fast) 28914a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford *Fast = true; 29014a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford return true; 29114a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford} 29214a926f13b768ee3771bb944bbbb29529a40dbe1Richard Sandiford 2931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 2941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Inline asm support 2951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 2961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandTargetLowering::ConstraintType 2981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::getConstraintType(const std::string &Constraint) const { 2991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Constraint.size() == 1) { 3001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (Constraint[0]) { 3011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'a': // Address register 3021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'd': // Data register (equivalent to 'r') 3031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'f': // Floating-point register 3041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'r': // General-purpose register 3051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return C_RegisterClass; 3061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'Q': // Memory with base and unsigned 12-bit displacement 3081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'R': // Likewise, plus an index 3091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'S': // Memory with base and signed 20-bit displacement 3101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'T': // Likewise, plus an index 3111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'm': // Equivalent to 'T'. 3121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return C_Memory; 3131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'I': // Unsigned 8-bit constant 3151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'J': // Unsigned 12-bit constant 3161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'K': // Signed 16-bit constant 3171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'L': // Signed 20-bit displacement (on all targets we support) 3181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'M': // 0x7fffffff 3191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return C_Other; 3201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 3221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 3241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 3251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return TargetLowering::getConstraintType(Constraint); 3261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 3271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandTargetLowering::ConstraintWeight SystemZTargetLowering:: 3291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandgetSingleConstraintMatchWeight(AsmOperandInfo &info, 3301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const char *constraint) const { 3311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ConstraintWeight weight = CW_Invalid; 3321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value *CallOperandVal = info.CallOperandVal; 3331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // If we don't have a value, we can't do a match, 3341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // but allow it at the lowest weight. 3351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CallOperandVal == NULL) 3361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return CW_Default; 3371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Type *type = CallOperandVal->getType(); 3381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Look at the constraint type. 3391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (*constraint) { 3401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 3411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = TargetLowering::getSingleConstraintMatchWeight(info, constraint); 3421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'a': // Address register 3451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'd': // Data register (equivalent to 'r') 3461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'r': // General-purpose register 3471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CallOperandVal->getType()->isIntegerTy()) 3481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Register; 3491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'f': // Floating-point register 3521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (type->isFloatingPointTy()) 3531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Register; 3541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'I': // Unsigned 8-bit constant 3571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) 3581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isUInt<8>(C->getZExtValue())) 3591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Constant; 3601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'J': // Unsigned 12-bit constant 3631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) 3641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isUInt<12>(C->getZExtValue())) 3651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Constant; 3661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'K': // Signed 16-bit constant 3691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) 3701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isInt<16>(C->getSExtValue())) 3711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Constant; 3721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'L': // Signed 20-bit displacement (on all targets we support) 3751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) 3761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isInt<20>(C->getSExtValue())) 3771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Constant; 3781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'M': // 0x7fffffff 3811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) 3821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (C->getZExtValue() == 0x7fffffff) 3831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand weight = CW_Constant; 3841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 3851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 3861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return weight; 3871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 3881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 3895e009541973b7935386055066689902aa7134e2dRichard Sandiford// Parse a "{tNNN}" register constraint for which the register type "t" 3905e009541973b7935386055066689902aa7134e2dRichard Sandiford// has already been verified. MC is the class associated with "t" and 3915e009541973b7935386055066689902aa7134e2dRichard Sandiford// Map maps 0-based register numbers to LLVM register numbers. 3925e009541973b7935386055066689902aa7134e2dRichard Sandifordstatic std::pair<unsigned, const TargetRegisterClass *> 3935e009541973b7935386055066689902aa7134e2dRichard SandifordparseRegisterNumber(const std::string &Constraint, 3945e009541973b7935386055066689902aa7134e2dRichard Sandiford const TargetRegisterClass *RC, const unsigned *Map) { 3955e009541973b7935386055066689902aa7134e2dRichard Sandiford assert(*(Constraint.end()-1) == '}' && "Missing '}'"); 3965e009541973b7935386055066689902aa7134e2dRichard Sandiford if (isdigit(Constraint[2])) { 3975e009541973b7935386055066689902aa7134e2dRichard Sandiford std::string Suffix(Constraint.data() + 2, Constraint.size() - 2); 3985e009541973b7935386055066689902aa7134e2dRichard Sandiford unsigned Index = atoi(Suffix.c_str()); 3995e009541973b7935386055066689902aa7134e2dRichard Sandiford if (Index < 16 && Map[Index]) 4005e009541973b7935386055066689902aa7134e2dRichard Sandiford return std::make_pair(Map[Index], RC); 4015e009541973b7935386055066689902aa7134e2dRichard Sandiford } 4025e009541973b7935386055066689902aa7134e2dRichard Sandiford return std::make_pair(0u, static_cast<TargetRegisterClass*>(0)); 4035e009541973b7935386055066689902aa7134e2dRichard Sandiford} 4045e009541973b7935386055066689902aa7134e2dRichard Sandiford 4051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstd::pair<unsigned, const TargetRegisterClass *> SystemZTargetLowering:: 4065b3fca50a08865f0db55fc92ad1c037a04e12177Chad RosiergetRegForInlineAsmConstraint(const std::string &Constraint, MVT VT) const { 4071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Constraint.size() == 1) { 4081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // GCC Constraint Letters 4091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (Constraint[0]) { 4101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: break; 4111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'd': // Data register (equivalent to 'r') 4121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'r': // General-purpose register 4131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VT == MVT::i64) 4141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::GR64BitRegClass); 4151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (VT == MVT::i128) 4161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::GR128BitRegClass); 4171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::GR32BitRegClass); 4181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'a': // Address register 4201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VT == MVT::i64) 4211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::ADDR64BitRegClass); 4221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (VT == MVT::i128) 4231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::ADDR128BitRegClass); 4241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::ADDR32BitRegClass); 4251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'f': // Floating-point register 4271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VT == MVT::f64) 4281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::FP64BitRegClass); 4291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (VT == MVT::f128) 4301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::FP128BitRegClass); 4311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return std::make_pair(0U, &SystemZ::FP32BitRegClass); 4321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 4331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 4345e009541973b7935386055066689902aa7134e2dRichard Sandiford if (Constraint[0] == '{') { 4355e009541973b7935386055066689902aa7134e2dRichard Sandiford // We need to override the default register parsing for GPRs and FPRs 4365e009541973b7935386055066689902aa7134e2dRichard Sandiford // because the interpretation depends on VT. The internal names of 4375e009541973b7935386055066689902aa7134e2dRichard Sandiford // the registers are also different from the external names 4385e009541973b7935386055066689902aa7134e2dRichard Sandiford // (F0D and F0S instead of F0, etc.). 4395e009541973b7935386055066689902aa7134e2dRichard Sandiford if (Constraint[1] == 'r') { 4405e009541973b7935386055066689902aa7134e2dRichard Sandiford if (VT == MVT::i32) 4415e009541973b7935386055066689902aa7134e2dRichard Sandiford return parseRegisterNumber(Constraint, &SystemZ::GR32BitRegClass, 4425e009541973b7935386055066689902aa7134e2dRichard Sandiford SystemZMC::GR32Regs); 4435e009541973b7935386055066689902aa7134e2dRichard Sandiford if (VT == MVT::i128) 4445e009541973b7935386055066689902aa7134e2dRichard Sandiford return parseRegisterNumber(Constraint, &SystemZ::GR128BitRegClass, 4455e009541973b7935386055066689902aa7134e2dRichard Sandiford SystemZMC::GR128Regs); 4465e009541973b7935386055066689902aa7134e2dRichard Sandiford return parseRegisterNumber(Constraint, &SystemZ::GR64BitRegClass, 4475e009541973b7935386055066689902aa7134e2dRichard Sandiford SystemZMC::GR64Regs); 4485e009541973b7935386055066689902aa7134e2dRichard Sandiford } 4495e009541973b7935386055066689902aa7134e2dRichard Sandiford if (Constraint[1] == 'f') { 4505e009541973b7935386055066689902aa7134e2dRichard Sandiford if (VT == MVT::f32) 4515e009541973b7935386055066689902aa7134e2dRichard Sandiford return parseRegisterNumber(Constraint, &SystemZ::FP32BitRegClass, 4525e009541973b7935386055066689902aa7134e2dRichard Sandiford SystemZMC::FP32Regs); 4535e009541973b7935386055066689902aa7134e2dRichard Sandiford if (VT == MVT::f128) 4545e009541973b7935386055066689902aa7134e2dRichard Sandiford return parseRegisterNumber(Constraint, &SystemZ::FP128BitRegClass, 4555e009541973b7935386055066689902aa7134e2dRichard Sandiford SystemZMC::FP128Regs); 4565e009541973b7935386055066689902aa7134e2dRichard Sandiford return parseRegisterNumber(Constraint, &SystemZ::FP64BitRegClass, 4575e009541973b7935386055066689902aa7134e2dRichard Sandiford SystemZMC::FP64Regs); 4585e009541973b7935386055066689902aa7134e2dRichard Sandiford } 4595e009541973b7935386055066689902aa7134e2dRichard Sandiford } 4601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return TargetLowering::getRegForInlineAsmConstraint(Constraint, VT); 4611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 4621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandvoid SystemZTargetLowering:: 4641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandLowerAsmOperandForConstraint(SDValue Op, std::string &Constraint, 4651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand std::vector<SDValue> &Ops, 4661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 4671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Only support length 1 constraints for now. 4681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Constraint.length() == 1) { 4691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (Constraint[0]) { 4701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'I': // Unsigned 8-bit constant 4711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) 4721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isUInt<8>(C->getZExtValue())) 4731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), 4741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getValueType())); 4751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 4761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'J': // Unsigned 12-bit constant 4781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) 4791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isUInt<12>(C->getZExtValue())) 4801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), 4811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getValueType())); 4821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 4831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'K': // Signed 16-bit constant 4851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) 4861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isInt<16>(C->getSExtValue())) 4871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getTargetConstant(C->getSExtValue(), 4881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getValueType())); 4891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 4901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'L': // Signed 20-bit displacement (on all targets we support) 4921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) 4931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (isInt<20>(C->getSExtValue())) 4941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getTargetConstant(C->getSExtValue(), 4951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getValueType())); 4961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 4971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 4981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case 'M': // 0x7fffffff 4991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Op)) 5001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (C->getZExtValue() == 0x7fffffff) 5011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getTargetConstant(C->getZExtValue(), 5021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getValueType())); 5031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 5041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 5051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 5061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand TargetLowering::LowerAsmOperandForConstraint(Op, Constraint, Ops, DAG); 5071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 5081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 5101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Calling conventions 5111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 5121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#include "SystemZGenCallingConv.inc" 5141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Value is a value that has been passed to us in the location described by VA 5161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// (and so has type VA.getLocVT()). Convert Value to VA.getValVT(), chaining 5171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// any loads onto Chain. 518ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trickstatic SDValue convertLocVTToValVT(SelectionDAG &DAG, SDLoc DL, 5191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCValAssign &VA, SDValue Chain, 5201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Value) { 5211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // If the argument has been promoted from a smaller type, insert an 5221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // assertion to capture this. 5231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.getLocInfo() == CCValAssign::SExt) 5241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value = DAG.getNode(ISD::AssertSext, DL, VA.getLocVT(), Value, 5251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getValueType(VA.getValVT())); 5261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (VA.getLocInfo() == CCValAssign::ZExt) 5271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value = DAG.getNode(ISD::AssertZext, DL, VA.getLocVT(), Value, 5281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getValueType(VA.getValVT())); 5291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.isExtInLoc()) 5311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value = DAG.getNode(ISD::TRUNCATE, DL, VA.getValVT(), Value); 5321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (VA.getLocInfo() == CCValAssign::Indirect) 5331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value = DAG.getLoad(VA.getValVT(), DL, Chain, Value, 5341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo(), false, false, false, 0); 5351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else 5361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(VA.getLocInfo() == CCValAssign::Full && "Unsupported getLocInfo"); 5371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Value; 5381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 5391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Value is a value of type VA.getValVT() that we need to copy into 5411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// the location described by VA. Return a copy of Value converted to 5421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// VA.getValVT(). The caller is responsible for handling indirect values. 543ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trickstatic SDValue convertValVTToLocVT(SelectionDAG &DAG, SDLoc DL, 5441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCValAssign &VA, SDValue Value) { 5451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (VA.getLocInfo()) { 5461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case CCValAssign::SExt: 5471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(ISD::SIGN_EXTEND, DL, VA.getLocVT(), Value); 5481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case CCValAssign::ZExt: 5491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(ISD::ZERO_EXTEND, DL, VA.getLocVT(), Value); 5501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case CCValAssign::AExt: 5511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(ISD::ANY_EXTEND, DL, VA.getLocVT(), Value); 5521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case CCValAssign::Full: 5531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Value; 5541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 5551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Unhandled getLocInfo()"); 5561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 5571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 5581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering:: 5601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandLowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool IsVarArg, 5611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SmallVectorImpl<ISD::InputArg> &Ins, 562ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL, SelectionDAG &DAG, 5631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVectorImpl<SDValue> &InVals) const { 5641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = DAG.getMachineFunction(); 5651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFrameInfo *MFI = MF.getFrameInfo(); 5661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineRegisterInfo &MRI = MF.getRegInfo(); 5671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZMachineFunctionInfo *FuncInfo = 5681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MF.getInfo<SystemZMachineFunctionInfo>(); 5691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SystemZFrameLowering *TFL = 5701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand static_cast<const SystemZFrameLowering *>(TM.getFrameLowering()); 5711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Assign locations to all of the incoming arguments. 5731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<CCValAssign, 16> ArgLocs; 5741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCState CCInfo(CallConv, IsVarArg, MF, TM, ArgLocs, *DAG.getContext()); 5751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCInfo.AnalyzeFormalArguments(Ins, CC_SystemZ); 5761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 5771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NumFixedGPRs = 0; 5781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NumFixedFPRs = 0; 5791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0, E = ArgLocs.size(); I != E; ++I) { 5801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ArgValue; 5811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCValAssign &VA = ArgLocs[I]; 5821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT LocVT = VA.getLocVT(); 5831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.isRegLoc()) { 5841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Arguments passed in registers 5851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const TargetRegisterClass *RC; 5861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (LocVT.getSimpleVT().SimpleTy) { 5871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 5881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Integers smaller than i64 should be promoted to i64. 5891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Unexpected argument type"); 5901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case MVT::i32: 5911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NumFixedGPRs += 1; 5921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RC = &SystemZ::GR32BitRegClass; 5931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 5941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case MVT::i64: 5951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NumFixedGPRs += 1; 5961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RC = &SystemZ::GR64BitRegClass; 5971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 5981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case MVT::f32: 5991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NumFixedFPRs += 1; 6001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RC = &SystemZ::FP32BitRegClass; 6011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 6021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case MVT::f64: 6031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NumFixedFPRs += 1; 6041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RC = &SystemZ::FP64BitRegClass; 6051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand break; 6061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 6071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned VReg = MRI.createVirtualRegister(RC); 6091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MRI.addLiveIn(VA.getLocReg(), VReg); 6101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ArgValue = DAG.getCopyFromReg(Chain, DL, VReg, LocVT); 6111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else { 6121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(VA.isMemLoc() && "Argument not register or memory"); 6131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Create the frame index object for this incoming parameter. 6151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int FI = MFI->CreateFixedObject(LocVT.getSizeInBits() / 8, 6161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand VA.getLocMemOffset(), true); 6171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Create the SelectionDAG nodes corresponding to a load 6191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // from this parameter. Unpromoted ints and floats are 6201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // passed as right-justified 8-byte values. 6211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 6221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue FIN = DAG.getFrameIndex(FI, PtrVT); 6231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.getLocVT() == MVT::i32 || VA.getLocVT() == MVT::f32) 6241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand FIN = DAG.getNode(ISD::ADD, DL, PtrVT, FIN, DAG.getIntPtrConstant(4)); 6251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ArgValue = DAG.getLoad(LocVT, DL, Chain, FIN, 6261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo::getFixedStack(FI), 6271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand false, false, false, 0); 6281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 6291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Convert the value of the argument register into the value that's 6311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // being passed. 6321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand InVals.push_back(convertLocVTToValVT(DAG, DL, VA, Chain, ArgValue)); 6331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 6341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsVarArg) { 6361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Save the number of non-varargs registers for later use by va_start, etc. 6371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand FuncInfo->setVarArgsFirstGPR(NumFixedGPRs); 6381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand FuncInfo->setVarArgsFirstFPR(NumFixedFPRs); 6391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Likewise the address (in the form of a frame index) of where the 6411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // first stack vararg would be. The 1-byte size here is arbitrary. 6421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t StackSize = CCInfo.getNextStackOffset(); 6431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand FuncInfo->setVarArgsFrameIndex(MFI->CreateFixedObject(1, StackSize, true)); 6441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ...and a similar frame index for the caller-allocated save area 6461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // that will be used to store the incoming registers. 6471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t RegSaveOffset = TFL->getOffsetOfLocalArea(); 6481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RegSaveIndex = MFI->CreateFixedObject(1, RegSaveOffset, true); 6491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand FuncInfo->setRegSaveFrameIndex(RegSaveIndex); 6501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Store the FPR varargs in the reserved frame slots. (We store the 6521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // GPRs as part of the prologue.) 6531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (NumFixedFPRs < SystemZ::NumArgFPRs) { 6541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue MemOps[SystemZ::NumArgFPRs]; 6551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = NumFixedFPRs; I < SystemZ::NumArgFPRs; ++I) { 6561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Offset = TFL->getRegSpillOffset(SystemZ::ArgFPRs[I]); 6571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int FI = MFI->CreateFixedObject(8, RegSaveOffset + Offset, true); 6581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue FIN = DAG.getFrameIndex(FI, getPointerTy()); 6591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned VReg = MF.addLiveIn(SystemZ::ArgFPRs[I], 6601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &SystemZ::FP64BitRegClass); 6611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ArgValue = DAG.getCopyFromReg(Chain, DL, VReg, MVT::f64); 6621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MemOps[I] = DAG.getStore(ArgValue.getValue(1), DL, ArgValue, FIN, 6631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo::getFixedStack(FI), 6641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand false, false, 0); 6651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 6671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Join the stores, which are independent of one another. 6681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, 6691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &MemOps[NumFixedFPRs], 6701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::NumArgFPRs - NumFixedFPRs); 6711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 6721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 6731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Chain; 6751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 6761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue 6781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::LowerCall(CallLoweringInfo &CLI, 6791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVectorImpl<SDValue> &InVals) const { 6801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG = CLI.DAG; 681ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc &DL = CLI.DL; 682a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs; 683a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper SmallVectorImpl<SDValue> &OutVals = CLI.OutVals; 684a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper SmallVectorImpl<ISD::InputArg> &Ins = CLI.Ins; 6851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Chain = CLI.Chain; 6861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Callee = CLI.Callee; 6871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool &isTailCall = CLI.IsTailCall; 6881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CallingConv::ID CallConv = CLI.CallConv; 6891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool IsVarArg = CLI.IsVarArg; 6901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = DAG.getMachineFunction(); 6911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 6921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // SystemZ target does not yet support tail call optimization. 6941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand isTailCall = false; 6951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 6961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Analyze the operands of the call, assigning locations to each operand. 6971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<CCValAssign, 16> ArgLocs; 6981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCState ArgCCInfo(CallConv, IsVarArg, MF, TM, ArgLocs, *DAG.getContext()); 6991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ArgCCInfo.AnalyzeCallOperands(Outs, CC_SystemZ); 7001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get a count of how many bytes are to be pushed on the stack. 7021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NumBytes = ArgCCInfo.getNextStackOffset(); 7031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Mark the start of the call. 7056e0b2a0cb0d398f175a5294bf0ad5488c714e8c2Andrew Trick Chain = DAG.getCALLSEQ_START(Chain, DAG.getConstant(NumBytes, PtrVT, true), 7066e0b2a0cb0d398f175a5294bf0ad5488c714e8c2Andrew Trick DL); 7071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Copy argument values to their designated locations. 7091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<std::pair<unsigned, SDValue>, 9> RegsToPass; 7101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<SDValue, 8> MemOpChains; 7111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue StackPtr; 7121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0, E = ArgLocs.size(); I != E; ++I) { 7131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCValAssign &VA = ArgLocs[I]; 7141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ArgValue = OutVals[I]; 7151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.getLocInfo() == CCValAssign::Indirect) { 7171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Store the argument in a stack slot and pass its address. 7181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SpillSlot = DAG.CreateStackTemporary(VA.getValVT()); 7191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int FI = cast<FrameIndexSDNode>(SpillSlot)->getIndex(); 7201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MemOpChains.push_back(DAG.getStore(Chain, DL, ArgValue, SpillSlot, 7211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo::getFixedStack(FI), 7221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand false, false, 0)); 7231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ArgValue = SpillSlot; 7241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else 7251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ArgValue = convertValVTToLocVT(DAG, DL, VA, ArgValue); 7261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.isRegLoc()) 7281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Queue up the argument copies and emit them at the end. 7291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RegsToPass.push_back(std::make_pair(VA.getLocReg(), ArgValue)); 7301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else { 7311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(VA.isMemLoc() && "Argument not register or memory"); 7321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Work out the address of the stack slot. Unpromoted ints and 7341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // floats are passed as right-justified 8-byte values. 7351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (!StackPtr.getNode()) 7361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand StackPtr = DAG.getCopyFromReg(Chain, DL, SystemZ::R15D, PtrVT); 7371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Offset = SystemZMC::CallFrameSize + VA.getLocMemOffset(); 7381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (VA.getLocVT() == MVT::i32 || VA.getLocVT() == MVT::f32) 7391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Offset += 4; 7401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Address = DAG.getNode(ISD::ADD, DL, PtrVT, StackPtr, 7411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getIntPtrConstant(Offset)); 7421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Emit the store. 7441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MemOpChains.push_back(DAG.getStore(Chain, DL, ArgValue, Address, 7451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo(), 7461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand false, false, 0)); 7471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 7481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 7491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Join the stores, which are independent of one another. 7511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (!MemOpChains.empty()) 7521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, 7531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &MemOpChains[0], MemOpChains.size()); 7541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Build a sequence of copy-to-reg nodes, chained and glued together. 7561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Glue; 7571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0, E = RegsToPass.size(); I != E; ++I) { 7581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getCopyToReg(Chain, DL, RegsToPass[I].first, 7591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RegsToPass[I].second, Glue); 7601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Glue = Chain.getValue(1); 7611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 7621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Accept direct calls by converting symbolic call addresses to the 7641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // associated Target* opcodes. 7651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) { 7661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Callee = DAG.getTargetGlobalAddress(G->getGlobal(), DL, PtrVT); 7671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee); 7681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else if (ExternalSymbolSDNode *E = dyn_cast<ExternalSymbolSDNode>(Callee)) { 7691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Callee = DAG.getTargetExternalSymbol(E->getSymbol(), PtrVT); 7701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Callee = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Callee); 7711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 7721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The first call operand is the chain and the second is the target address. 7741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<SDValue, 8> Ops; 7751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(Chain); 7761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(Callee); 7771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Add argument registers to the end of the list so that they are 7791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // known live into the call. 7801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0, E = RegsToPass.size(); I != E; ++I) 7811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getRegister(RegsToPass[I].first, 7821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RegsToPass[I].second.getValueType())); 7831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Glue the call to the argument copies, if any. 7851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Glue.getNode()) 7861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(Glue); 7871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Emit the call. 7891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue); 7901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getNode(SystemZISD::CALL, DL, NodeTys, &Ops[0], Ops.size()); 7911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Glue = Chain.getValue(1); 7921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 7931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Mark the end of the call, which is glued to the call itself. 7941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getCALLSEQ_END(Chain, 7951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(NumBytes, PtrVT, true), 7961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(0, PtrVT, true), 7976e0b2a0cb0d398f175a5294bf0ad5488c714e8c2Andrew Trick Glue, DL); 7981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Glue = Chain.getValue(1); 7991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Assign locations to each value returned by this call. 8011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<CCValAssign, 16> RetLocs; 8021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCState RetCCInfo(CallConv, IsVarArg, MF, TM, RetLocs, *DAG.getContext()); 8031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetCCInfo.AnalyzeCallResult(Ins, RetCC_SystemZ); 8041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Copy all of the result registers out of their specified physreg. 8061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0, E = RetLocs.size(); I != E; ++I) { 8071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCValAssign &VA = RetLocs[I]; 8081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Copy the value out, gluing the copy to the end of the call sequence. 8101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue RetValue = DAG.getCopyFromReg(Chain, DL, VA.getLocReg(), 8111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand VA.getLocVT(), Glue); 8121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = RetValue.getValue(1); 8131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Glue = RetValue.getValue(2); 8141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Convert the value of the return register into the value that's 8161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // being returned. 8171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand InVals.push_back(convertLocVTToValVT(DAG, DL, VA, Chain, RetValue)); 8181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 8191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Chain; 8211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 8221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue 8241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::LowerReturn(SDValue Chain, 8251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CallingConv::ID CallConv, bool IsVarArg, 8261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SmallVectorImpl<ISD::OutputArg> &Outs, 8271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SmallVectorImpl<SDValue> &OutVals, 828ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL, SelectionDAG &DAG) const { 8291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = DAG.getMachineFunction(); 8301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Assign locations to each returned value. 8321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<CCValAssign, 16> RetLocs; 8331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCState RetCCInfo(CallConv, IsVarArg, MF, TM, RetLocs, *DAG.getContext()); 8341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetCCInfo.AnalyzeReturn(Outs, RetCC_SystemZ); 8351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Quick exit for void returns 8371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (RetLocs.empty()) 8381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, Chain); 8391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Copy the result values into the output registers. 8411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Glue; 8421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SmallVector<SDValue, 4> RetOps; 8431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetOps.push_back(Chain); 8441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0, E = RetLocs.size(); I != E; ++I) { 8451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCValAssign &VA = RetLocs[I]; 8461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue RetValue = OutVals[I]; 8471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Make the return register live on exit. 8491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(VA.isRegLoc() && "Can only return in registers!"); 8501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Promote the value as required. 8521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetValue = convertValVTToLocVT(DAG, DL, VA, RetValue); 8531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Chain and glue the copies together. 8551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Reg = VA.getLocReg(); 8561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getCopyToReg(Chain, DL, Reg, RetValue, Glue); 8571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Glue = Chain.getValue(1); 8581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetOps.push_back(DAG.getRegister(Reg, VA.getLocVT())); 8591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 8601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Update chain and glue. 8621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetOps[0] = Chain; 8631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Glue.getNode()) 8641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetOps.push_back(Glue); 8651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(SystemZISD::RET_FLAG, DL, MVT::Other, 8671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand RetOps.data(), RetOps.size()); 8681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 8691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// CC is a comparison that will be implemented using an integer or 8711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// floating-point comparison. Return the condition code mask for 8721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// a branch on true. In the integer case, CCMASK_CMP_UO is set for 8731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// unsigned comparisons and clear for signed ones. In the floating-point 8741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// case, CCMASK_CMP_UO has its normal mask meaning (unordered). 8751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic unsigned CCMaskForCondCode(ISD::CondCode CC) { 8761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#define CONV(X) \ 8771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SET##X: return SystemZ::CCMASK_CMP_##X; \ 8781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SETO##X: return SystemZ::CCMASK_CMP_##X; \ 8791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SETU##X: return SystemZ::CCMASK_CMP_UO | SystemZ::CCMASK_CMP_##X 8801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (CC) { 8821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 8831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Invalid integer condition!"); 8841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CONV(EQ); 8861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CONV(NE); 8871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CONV(GT); 8881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CONV(GE); 8891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CONV(LT); 8901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CONV(LE); 8911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SETO: return SystemZ::CCMASK_CMP_O; 8931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SETUO: return SystemZ::CCMASK_CMP_UO; 8941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 8951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#undef CONV 8961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 8971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 8981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// If a comparison described by IsUnsigned, CCMask, CmpOp0 and CmpOp1 8991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// is suitable for CLI(Y), CHHSI or CLHHSI, adjust the operands as necessary. 9001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic void adjustSubwordCmp(SelectionDAG &DAG, bool &IsUnsigned, 9011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue &CmpOp0, SDValue &CmpOp1, 9021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned &CCMask) { 9031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // For us to make any changes, it must a comparison between a single-use 9041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // load and a constant. 9051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (!CmpOp0.hasOneUse() || 9061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CmpOp0.getOpcode() != ISD::LOAD || 9071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CmpOp1.getOpcode() != ISD::Constant) 9081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 9091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We must have an 8- or 16-bit load. 9111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand LoadSDNode *Load = cast<LoadSDNode>(CmpOp0); 9121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NumBits = Load->getMemoryVT().getStoreSizeInBits(); 9131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (NumBits != 8 && NumBits != 16) 9141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 9151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The load must be an extending one and the constant must be within the 9171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // range of the unextended value. 9181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ConstantSDNode *Constant = cast<ConstantSDNode>(CmpOp1); 9191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand uint64_t Value = Constant->getZExtValue(); 9201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand uint64_t Mask = (1 << NumBits) - 1; 9211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Load->getExtensionType() == ISD::SEXTLOAD) { 9221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t SignedValue = Constant->getSExtValue(); 92312cba852f550ae2d2fdb6b6be28d087aae585a76Aaron Ballman if (uint64_t(SignedValue) + (1ULL << (NumBits - 1)) > Mask) 9241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 9251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Unsigned comparison between two sign-extended values is equivalent 9261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // to unsigned comparison between two zero-extended values. 9271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsUnsigned) 9281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value &= Mask; 9291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (CCMask == SystemZ::CCMASK_CMP_EQ || 9301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CCMask == SystemZ::CCMASK_CMP_NE) 9311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Any choice of IsUnsigned is OK for equality comparisons. 9321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We could use either CHHSI or CLHHSI for 16-bit comparisons, 9331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // but since we use CLHHSI for zero extensions, it seems better 9341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // to be consistent and do the same here. 9351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value &= Mask, IsUnsigned = true; 9361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (NumBits == 8) { 9371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Try to treat the comparison as unsigned, so that we can use CLI. 9381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Adjust CCMask and Value as necessary. 9391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Value == 0 && CCMask == SystemZ::CCMASK_CMP_LT) 9401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Test whether the high bit of the byte is set. 9411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value = 127, CCMask = SystemZ::CCMASK_CMP_GT, IsUnsigned = true; 9421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (SignedValue == -1 && CCMask == SystemZ::CCMASK_CMP_GT) 9431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Test whether the high bit of the byte is clear. 9441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value = 128, CCMask = SystemZ::CCMASK_CMP_LT, IsUnsigned = true; 9451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else 9461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // No instruction exists for this combination. 9471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 9481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 9491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else if (Load->getExtensionType() == ISD::ZEXTLOAD) { 9501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Value > Mask) 9511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 9521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Signed comparison between two zero-extended values is equivalent 9531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // to unsigned comparison. 9541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand IsUnsigned = true; 9551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else 9561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return; 9571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Make sure that the first operand is an i32 of the right extension type. 9591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ISD::LoadExtType ExtType = IsUnsigned ? ISD::ZEXTLOAD : ISD::SEXTLOAD; 9601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp0.getValueType() != MVT::i32 || 9611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Load->getExtensionType() != ExtType) 962ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick CmpOp0 = DAG.getExtLoad(ExtType, SDLoc(Load), MVT::i32, 9631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Load->getChain(), Load->getBasePtr(), 9641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Load->getPointerInfo(), Load->getMemoryVT(), 9651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Load->isVolatile(), Load->isNonTemporal(), 9661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Load->getAlignment()); 9671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Make sure that the second operand is an i32 with the right value. 9691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp1.getValueType() != MVT::i32 || 9701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Value != Constant->getZExtValue()) 9711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CmpOp1 = DAG.getConstant(Value, MVT::i32); 9721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 9731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Return true if a comparison described by CCMask, CmpOp0 and CmpOp1 9751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// is an equality comparison that is better implemented using unsigned 9761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// rather than signed comparison instructions. 9771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic bool preferUnsignedComparison(SelectionDAG &DAG, SDValue CmpOp0, 9781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CmpOp1, unsigned CCMask) { 9791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The test must be for equality or inequality. 9801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CCMask != SystemZ::CCMASK_CMP_EQ && CCMask != SystemZ::CCMASK_CMP_NE) 9811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return false; 9821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp1.getOpcode() == ISD::Constant) { 9841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand uint64_t Value = cast<ConstantSDNode>(CmpOp1)->getSExtValue(); 9851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // If we're comparing with memory, prefer unsigned comparisons for 9871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // values that are in the unsigned 16-bit range but not the signed 9881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // 16-bit range. We want to use CLFHSI and CLGHSI. 9891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp0.hasOneUse() && 9901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ISD::isNormalLoad(CmpOp0.getNode()) && 9911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand (Value >= 32768 && Value < 65536)) 9921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return true; 9931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use unsigned comparisons for values that are in the CLGFI range 9951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // but not in the CGFI range. 9961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp0.getValueType() == MVT::i64 && (Value >> 31) == 1) 9971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return true; 9981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 9991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return false; 10001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 10011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Prefer CL for zero-extended loads. 10031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp1.getOpcode() == ISD::ZERO_EXTEND || 10041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ISD::isZEXTLoad(CmpOp1.getNode())) 10051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return true; 10061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ...and for "in-register" zero extensions. 10081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CmpOp1.getOpcode() == ISD::AND && CmpOp1.getValueType() == MVT::i64) { 10091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Mask = CmpOp1.getOperand(1); 10101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Mask.getOpcode() == ISD::Constant && 10111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand cast<ConstantSDNode>(Mask)->getZExtValue() == 0xffffffff) 10121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return true; 10131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 10141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return false; 10161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 10171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10186824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford// Return a target node that compares CmpOp0 with CmpOp1 and stores a 10196824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford// 2-bit result in CC. Set CCValid to the CCMASK_* of all possible 10206824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford// 2-bit results and CCMask to the subset of those results that are 10216824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford// associated with Cond. 10221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic SDValue emitCmp(SelectionDAG &DAG, SDValue CmpOp0, SDValue CmpOp1, 10236824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford ISD::CondCode Cond, unsigned &CCValid, 10246824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned &CCMask) { 10251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool IsUnsigned = false; 10266824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford CCMask = CCMaskForCondCode(Cond); 10276824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford if (CmpOp0.getValueType().isFloatingPoint()) 10286824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford CCValid = SystemZ::CCMASK_FCMP; 10296824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford else { 10301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand IsUnsigned = CCMask & SystemZ::CCMASK_CMP_UO; 10316824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford CCValid = SystemZ::CCMASK_ICMP; 10326824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford CCMask &= CCValid; 10331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand adjustSubwordCmp(DAG, IsUnsigned, CmpOp0, CmpOp1, CCMask); 10341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (preferUnsignedComparison(DAG, CmpOp0, CmpOp1, CCMask)) 10351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand IsUnsigned = true; 10361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 10371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1038ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(CmpOp0); 10391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode((IsUnsigned ? SystemZISD::UCMP : SystemZISD::CMP), 10401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DL, MVT::Glue, CmpOp0, CmpOp1); 10411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 10421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Lower a binary operation that produces two VT results, one in each 10441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// half of a GR128 pair. Op0 and Op1 are the VT operands to the operation, 10451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Extend extends Op0 to a GR128, and Opcode performs the GR128 operation 10461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// on the extended Op0 and (unextended) Op1. Store the even register result 10471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// in Even and the odd register result in Odd. 1048ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trickstatic void lowerGR128Binary(SelectionDAG &DAG, SDLoc DL, EVT VT, 10491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Extend, unsigned Opcode, 10501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Op0, SDValue Op1, 10511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue &Even, SDValue &Odd) { 10521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *In128 = DAG.getMachineNode(Extend, DL, MVT::Untyped, Op0); 10531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result = DAG.getNode(Opcode, DL, MVT::Untyped, 10541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue(In128, 0), Op1); 10551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool Is32Bit = is32Bit(VT); 10561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SubReg0 = DAG.getTargetConstant(SystemZ::even128(Is32Bit), VT); 10571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SubReg1 = DAG.getTargetConstant(SystemZ::odd128(Is32Bit), VT); 10581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *Reg0 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL, 10591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand VT, Result, SubReg0); 10601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *Reg1 = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL, 10611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand VT, Result, SubReg1); 10621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Even = SDValue(Reg0, 0); 10631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Odd = SDValue(Reg1, 0); 10641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 10651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerBR_CC(SDValue Op, SelectionDAG &DAG) const { 10671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Chain = Op.getOperand(0); 10681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(1))->get(); 10691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CmpOp0 = Op.getOperand(2); 10701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CmpOp1 = Op.getOperand(3); 10711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Dest = Op.getOperand(4); 1072ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 10731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10746824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned CCValid, CCMask; 10756824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford SDValue Flags = emitCmp(DAG, CmpOp0, CmpOp1, CC, CCValid, CCMask); 10761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(SystemZISD::BR_CCMASK, DL, Op.getValueType(), 10776824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford Chain, DAG.getConstant(CCValid, MVT::i32), 10786824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford DAG.getConstant(CCMask, MVT::i32), Dest, Flags); 10791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 10801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerSELECT_CC(SDValue Op, 10821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 10831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CmpOp0 = Op.getOperand(0); 10841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CmpOp1 = Op.getOperand(1); 10851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue TrueOp = Op.getOperand(2); 10861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue FalseOp = Op.getOperand(3); 10871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ISD::CondCode CC = cast<CondCodeSDNode>(Op.getOperand(4))->get(); 1088ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 10891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10906824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned CCValid, CCMask; 10916824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford SDValue Flags = emitCmp(DAG, CmpOp0, CmpOp1, CC, CCValid, CCMask); 10921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 10936824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford SmallVector<SDValue, 5> Ops; 10941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(TrueOp); 10951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(FalseOp); 10966824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford Ops.push_back(DAG.getConstant(CCValid, MVT::i32)); 10971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(DAG.getConstant(CCMask, MVT::i32)); 10981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Ops.push_back(Flags); 10991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDVTList VTs = DAG.getVTList(Op.getValueType(), MVT::Glue); 11011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(SystemZISD::SELECT_CCMASK, DL, VTs, &Ops[0], Ops.size()); 11021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 11031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerGlobalAddress(GlobalAddressSDNode *Node, 11051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 1106ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Node); 11071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const GlobalValue *GV = Node->getGlobal(); 11081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t Offset = Node->getOffset(); 11091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 11101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Reloc::Model RM = TM.getRelocationModel(); 11111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CodeModel::Model CM = TM.getCodeModel(); 11121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result; 11141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Subtarget.isPC32DBLSymbol(GV, RM, CM)) { 11151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Make sure that the offset is aligned to a halfword. If it isn't, 11161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // create an "anchor" at the previous 12-bit boundary. 11171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // FIXME check whether there is a better way of handling this. 11181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Offset & 1) { 11191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 11201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Offset & ~uint64_t(0xfff)); 11211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Offset &= 0xfff; 11221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else { 11231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, Offset); 11241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Offset = 0; 11251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 11261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result); 11271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else { 11281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, SystemZII::MO_GOT); 11291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result); 11301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result, 11311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo::getGOT(), false, false, false, 0); 11321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 11331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // If there was a non-zero offset that we didn't fold, create an explicit 11351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // addition for it. 11361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Offset != 0) 11371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getNode(ISD::ADD, DL, PtrVT, Result, 11381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(Offset, PtrVT)); 11391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Result; 11411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 11421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerGlobalTLSAddress(GlobalAddressSDNode *Node, 11441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 1145ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Node); 11461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const GlobalValue *GV = Node->getGlobal(); 11471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 11481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand TLSModel::Model model = TM.getTLSModel(GV); 11491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (model != TLSModel::LocalExec) 11511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("only local-exec TLS mode supported"); 11521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The high part of the thread pointer is in access register 0. 11541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue TPHi = DAG.getNode(SystemZISD::EXTRACT_ACCESS, DL, MVT::i32, 11551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(0, MVT::i32)); 11561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand TPHi = DAG.getNode(ISD::ANY_EXTEND, DL, PtrVT, TPHi); 11571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The low part of the thread pointer is in access register 1. 11591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue TPLo = DAG.getNode(SystemZISD::EXTRACT_ACCESS, DL, MVT::i32, 11601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(1, MVT::i32)); 11611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand TPLo = DAG.getNode(ISD::ZERO_EXTEND, DL, PtrVT, TPLo); 11621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Merge them into a single 64-bit address. 11641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue TPHiShifted = DAG.getNode(ISD::SHL, DL, PtrVT, TPHi, 11651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(32, PtrVT)); 11661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue TP = DAG.getNode(ISD::OR, DL, PtrVT, TPHiShifted, TPLo); 11671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the offset of GA from the thread pointer. 11691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZConstantPoolValue *CPV = 11701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZConstantPoolValue::Create(GV, SystemZCP::NTPOFF); 11711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Force the offset into the constant pool and load it from there. 11731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CPAddr = DAG.getConstantPool(CPV, PtrVT, 8); 11741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Offset = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), 11751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CPAddr, MachinePointerInfo::getConstantPool(), 11761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand false, false, false, 0); 11771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Add the base and offset together. 11791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(ISD::ADD, DL, PtrVT, TP, Offset); 11801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 11811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerBlockAddress(BlockAddressSDNode *Node, 11831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 1184ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Node); 11851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const BlockAddress *BA = Node->getBlockAddress(); 11861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t Offset = Node->getOffset(); 11871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 11881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result = DAG.getTargetBlockAddress(BA, PtrVT, Offset); 11901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result); 11911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Result; 11921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 11931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 11941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerJumpTable(JumpTableSDNode *JT, 11951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 1196ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(JT); 11971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 11981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), PtrVT); 11991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use LARL to load the address of the table. 12011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result); 12021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 12031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerConstantPool(ConstantPoolSDNode *CP, 12051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 1206ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(CP); 12071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 12081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result; 12101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (CP->isMachineConstantPoolEntry()) 12111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getTargetConstantPool(CP->getMachineCPVal(), PtrVT, 12121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CP->getAlignment()); 12131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else 12141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Result = DAG.getTargetConstantPool(CP->getConstVal(), PtrVT, 12151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CP->getAlignment(), CP->getOffset()); 12161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use LARL to load the address of the constant pool entry. 12181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(SystemZISD::PCREL_WRAPPER, DL, PtrVT, Result); 12191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 12201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerBITCAST(SDValue Op, 12221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 1223ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 12241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue In = Op.getOperand(0); 12251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT InVT = In.getValueType(); 12261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT ResVT = Op.getValueType(); 12271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SubReg32 = DAG.getTargetConstant(SystemZ::subreg_32bit, MVT::i64); 12291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Shift32 = DAG.getConstant(32, MVT::i64); 12301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (InVT == MVT::i32 && ResVT == MVT::f32) { 12311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue In64 = DAG.getNode(ISD::ANY_EXTEND, DL, MVT::i64, In); 12321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Shift = DAG.getNode(ISD::SHL, DL, MVT::i64, In64, Shift32); 12331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::f64, Shift); 12341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *Out = DAG.getMachineNode(TargetOpcode::EXTRACT_SUBREG, DL, 12351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT::f32, Out64, SubReg32); 12361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return SDValue(Out, 0); 12371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 12381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (InVT == MVT::f32 && ResVT == MVT::i32) { 12391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *U64 = DAG.getMachineNode(TargetOpcode::IMPLICIT_DEF, DL, MVT::f64); 12401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *In64 = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, DL, 12411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT::f64, SDValue(U64, 0), In, SubReg32); 12421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Out64 = DAG.getNode(ISD::BITCAST, DL, MVT::i64, SDValue(In64, 0)); 12431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Shift = DAG.getNode(ISD::SRL, DL, MVT::i64, Out64, Shift32); 12441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Out = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Shift); 12451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Out; 12461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 12471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Unexpected bitcast combination"); 12481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 12491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerVASTART(SDValue Op, 12511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 12521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = DAG.getMachineFunction(); 12531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZMachineFunctionInfo *FuncInfo = 12541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MF.getInfo<SystemZMachineFunctionInfo>(); 12551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = getPointerTy(); 12561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Chain = Op.getOperand(0); 12581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Addr = Op.getOperand(1); 12591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue(); 1260ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 12611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The initial values of each field. 12631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const unsigned NumFields = 4; 12641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Fields[NumFields] = { 12651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(FuncInfo->getVarArgsFirstGPR(), PtrVT), 12661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(FuncInfo->getVarArgsFirstFPR(), PtrVT), 12671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), PtrVT), 12681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getFrameIndex(FuncInfo->getRegSaveFrameIndex(), PtrVT) 12691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand }; 12701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Store each field into its respective slot. 12721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue MemOps[NumFields]; 12731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Offset = 0; 12741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand for (unsigned I = 0; I < NumFields; ++I) { 12751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue FieldAddr = Addr; 12761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Offset != 0) 12771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand FieldAddr = DAG.getNode(ISD::ADD, DL, PtrVT, FieldAddr, 12781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getIntPtrConstant(Offset)); 12791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MemOps[I] = DAG.getStore(Chain, DL, Fields[I], FieldAddr, 12801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo(SV, Offset), 12811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand false, false, 0); 12821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Offset += 8; 12831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 12841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, MemOps, NumFields); 12851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 12861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerVACOPY(SDValue Op, 12881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 12891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Chain = Op.getOperand(0); 12901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue DstPtr = Op.getOperand(1); 12911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SrcPtr = Op.getOperand(2); 12921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const Value *DstSV = cast<SrcValueSDNode>(Op.getOperand(3))->getValue(); 12931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const Value *SrcSV = cast<SrcValueSDNode>(Op.getOperand(4))->getValue(); 1294ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 12951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 12961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getMemcpy(Chain, DL, DstPtr, SrcPtr, DAG.getIntPtrConstant(32), 12971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand /*Align*/8, /*isVolatile*/false, /*AlwaysInline*/false, 12981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachinePointerInfo(DstSV), MachinePointerInfo(SrcSV)); 12991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 13001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering:: 13021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandlowerDYNAMIC_STACKALLOC(SDValue Op, SelectionDAG &DAG) const { 13031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Chain = Op.getOperand(0); 13041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Size = Op.getOperand(1); 1305ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 13061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned SPReg = getStackPointerRegisterToSaveRestore(); 13081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get a reference to the stack pointer. 13101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue OldSP = DAG.getCopyFromReg(Chain, DL, SPReg, MVT::i64); 13111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the new stack pointer value. 13131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue NewSP = DAG.getNode(ISD::SUB, DL, MVT::i64, OldSP, Size); 13141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Copy the new stack pointer back. 13161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Chain = DAG.getCopyToReg(Chain, DL, SPReg, NewSP); 13171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // The allocated data lives above the 160 bytes allocated for the standard 13191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // frame, plus any outgoing stack arguments. We don't know how much that 13201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // amounts to yet, so emit a special ADJDYNALLOC placeholder. 13211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ArgAdjust = DAG.getNode(SystemZISD::ADJDYNALLOC, DL, MVT::i64); 13221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result = DAG.getNode(ISD::ADD, DL, MVT::i64, NewSP, ArgAdjust); 13231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[2] = { Result, Chain }; 13251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getMergeValues(Ops, 2, DL); 13261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 13271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerUMUL_LOHI(SDValue Op, 13291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 13301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT VT = Op.getValueType(); 1331ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 13321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(!is32Bit(VT) && "Only support 64-bit UMUL_LOHI"); 13331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // UMUL_LOHI64 returns the low result in the odd register and the high 13351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // result in the even register. UMUL_LOHI is defined to return the 13361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // low half first, so the results are in reverse order. 13371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[2]; 13381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand lowerGR128Binary(DAG, DL, VT, SystemZ::AEXT128_64, SystemZISD::UMUL_LOHI64, 13391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getOperand(0), Op.getOperand(1), Ops[1], Ops[0]); 13401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getMergeValues(Ops, 2, DL); 13411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 13421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerSDIVREM(SDValue Op, 13441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 13451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Op0 = Op.getOperand(0); 13461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Op1 = Op.getOperand(1); 13471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT VT = Op.getValueType(); 1348ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 134935b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford unsigned Opcode; 13501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We use DSGF for 32-bit division. 13521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (is32Bit(VT)) { 13531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op0 = DAG.getNode(ISD::SIGN_EXTEND, DL, MVT::i64, Op0); 135435b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford Opcode = SystemZISD::SDIVREM32; 135535b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford } else if (DAG.ComputeNumSignBits(Op1) > 32) { 135635b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford Op1 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Op1); 135735b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford Opcode = SystemZISD::SDIVREM32; 135835b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford } else 135935b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford Opcode = SystemZISD::SDIVREM64; 13601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // DSG(F) takes a 64-bit dividend, so the even register in the GR128 13621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // input is "don't care". The instruction returns the remainder in 13631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // the even register and the quotient in the odd register. 13641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[2]; 136535b7bebe1162326c38217ff80d4a49fbbffcc365Richard Sandiford lowerGR128Binary(DAG, DL, VT, SystemZ::AEXT128_64, Opcode, 13661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op0, Op1, Ops[1], Ops[0]); 13671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getMergeValues(Ops, 2, DL); 13681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 13691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerUDIVREM(SDValue Op, 13711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 13721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT VT = Op.getValueType(); 1373ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 13741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // DL(G) uses a double-width dividend, so we need to clear the even 13761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // register in the GR128 input. The instruction returns the remainder 13771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // in the even register and the quotient in the odd register. 13781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[2]; 13791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (is32Bit(VT)) 13801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand lowerGR128Binary(DAG, DL, VT, SystemZ::ZEXT128_32, SystemZISD::UDIVREM32, 13811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getOperand(0), Op.getOperand(1), Ops[1], Ops[0]); 13821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else 13831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand lowerGR128Binary(DAG, DL, VT, SystemZ::ZEXT128_64, SystemZISD::UDIVREM64, 13841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Op.getOperand(0), Op.getOperand(1), Ops[1], Ops[0]); 13851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getMergeValues(Ops, 2, DL); 13861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 13871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerOR(SDValue Op, SelectionDAG &DAG) const { 13891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(Op.getValueType() == MVT::i64 && "Should be 64-bit operation"); 13901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the known-zero masks for each operand. 13921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[] = { Op.getOperand(0), Op.getOperand(1) }; 13931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand APInt KnownZero[2], KnownOne[2]; 13941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.ComputeMaskedBits(Ops[0], KnownZero[0], KnownOne[0]); 13951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.ComputeMaskedBits(Ops[1], KnownZero[1], KnownOne[1]); 13961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 13971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // See if the upper 32 bits of one operand and the lower 32 bits of the 13981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // other are known zero. They are the low and high operands respectively. 13991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand uint64_t Masks[] = { KnownZero[0].getZExtValue(), 14001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand KnownZero[1].getZExtValue() }; 14011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned High, Low; 14021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if ((Masks[0] >> 32) == 0xffffffff && uint32_t(Masks[1]) == 0xffffffff) 14031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand High = 1, Low = 0; 14041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if ((Masks[1] >> 32) == 0xffffffff && uint32_t(Masks[0]) == 0xffffffff) 14051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand High = 0, Low = 1; 14061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else 14071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Op; 14081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue LowOp = Ops[Low]; 14101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue HighOp = Ops[High]; 14111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // If the high part is a constant, we're better off using IILH. 14131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (HighOp.getOpcode() == ISD::Constant) 14141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Op; 14151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // If the low part is a constant that is outside the range of LHI, 14171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // then we're better off using IILF. 14181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (LowOp.getOpcode() == ISD::Constant) { 14191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t Value = int32_t(cast<ConstantSDNode>(LowOp)->getZExtValue()); 14201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (!isInt<16>(Value)) 14211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Op; 14221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 14231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Check whether the high part is an AND that doesn't change the 14251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // high 32 bits and just masks out low bits. We can skip it if so. 14261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (HighOp.getOpcode() == ISD::AND && 14271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand HighOp.getOperand(1).getOpcode() == ISD::Constant) { 14281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand ConstantSDNode *MaskNode = cast<ConstantSDNode>(HighOp.getOperand(1)); 14291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand uint64_t Mask = MaskNode->getZExtValue() | Masks[High]; 14301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if ((Mask >> 32) == 0xffffffff) 14311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand HighOp = HighOp.getOperand(0); 14321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 14331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Take advantage of the fact that all GR32 operations only change the 14351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // low 32 bits by truncating Low to an i32 and inserting it directly 14361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // using a subreg. The interesting cases are those where the truncation 14371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // can be folded. 1438ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Op); 14391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Low32 = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, LowOp); 14401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SubReg32 = DAG.getTargetConstant(SystemZ::subreg_32bit, MVT::i64); 14411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDNode *Result = DAG.getMachineNode(TargetOpcode::INSERT_SUBREG, DL, 14421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MVT::i64, HighOp, Low32, SubReg32); 14431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return SDValue(Result, 0); 14441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 14451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Op is an 8-, 16-bit or 32-bit ATOMIC_LOAD_* operation. Lower the first 14471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// two into the fullword ATOMIC_LOADW_* operation given by Opcode. 14481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerATOMIC_LOAD(SDValue Op, 14491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG, 14501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Opcode) const { 14511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand AtomicSDNode *Node = cast<AtomicSDNode>(Op.getNode()); 14521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // 32-bit operations need no code outside the main loop. 14541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT NarrowVT = Node->getMemoryVT(); 14551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT WideVT = MVT::i32; 14561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (NarrowVT == WideVT) 14571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Op; 14581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t BitSize = NarrowVT.getSizeInBits(); 14601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ChainIn = Node->getChain(); 14611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Addr = Node->getBasePtr(); 14621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Src2 = Node->getVal(); 14631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineMemOperand *MMO = Node->getMemOperand(); 1464ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Node); 14651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = Addr.getValueType(); 14661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Convert atomic subtracts of constants into additions. 14681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Opcode == SystemZISD::ATOMIC_LOADW_SUB) 14691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ConstantSDNode *Const = dyn_cast<ConstantSDNode>(Src2)) { 14701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Opcode = SystemZISD::ATOMIC_LOADW_ADD; 14711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Src2 = DAG.getConstant(-Const->getSExtValue(), Src2.getValueType()); 14721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 14731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the address of the containing word. 14751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr, 14761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(-4, PtrVT)); 14771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the number of bits that the word must be rotated left in order 14791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // to bring the field to the top bits of a GR32. 14801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr, 14811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(3, PtrVT)); 14821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift); 14831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the complementing shift amount, for rotating a field in the top 14851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // bits back to its proper position. 14861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT, 14871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(0, WideVT), BitShift); 14881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 14891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Extend the source operand to 32 bits and prepare it for the inner loop. 14901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ATOMIC_SWAPW uses RISBG to rotate the field left, but all other 14911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // operations require the source to be shifted in advance. (This shift 14921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // can be folded if the source is constant.) For AND and NAND, the lower 14931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // bits must be set, while for other opcodes they should be left clear. 14941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Opcode != SystemZISD::ATOMIC_SWAPW) 14951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Src2 = DAG.getNode(ISD::SHL, DL, WideVT, Src2, 14961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(32 - BitSize, WideVT)); 14971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Opcode == SystemZISD::ATOMIC_LOADW_AND || 14981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Opcode == SystemZISD::ATOMIC_LOADW_NAND) 14991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand Src2 = DAG.getNode(ISD::OR, DL, WideVT, Src2, 15001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(uint32_t(-1) >> BitSize, WideVT)); 15011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Construct the ATOMIC_LOADW_* node. 15031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDVTList VTList = DAG.getVTList(WideVT, MVT::Other); 15041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[] = { ChainIn, AlignedAddr, Src2, BitShift, NegBitShift, 15051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(BitSize, WideVT) }; 15061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue AtomicOp = DAG.getMemIntrinsicNode(Opcode, DL, VTList, Ops, 15071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand array_lengthof(Ops), 15081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NarrowVT, MMO); 15091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Rotate the result of the final CS so that the field is in the lower 15111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // bits of a GR32, then truncate it. 15121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ResultShift = DAG.getNode(ISD::ADD, DL, WideVT, BitShift, 15131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(BitSize, WideVT)); 15141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Result = DAG.getNode(ISD::ROTL, DL, WideVT, AtomicOp, ResultShift); 15151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue RetOps[2] = { Result, AtomicOp.getValue(1) }; 15171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DAG.getMergeValues(RetOps, 2, DL); 15181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 15191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Node is an 8- or 16-bit ATOMIC_CMP_SWAP operation. Lower the first two 15211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// into a fullword ATOMIC_CMP_SWAPW operation. 15221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerATOMIC_CMP_SWAP(SDValue Op, 15231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 15241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand AtomicSDNode *Node = cast<AtomicSDNode>(Op.getNode()); 15251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // We have native support for 32-bit compare and swap. 15271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT NarrowVT = Node->getMemoryVT(); 15281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT WideVT = MVT::i32; 15291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (NarrowVT == WideVT) 15301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return Op; 15311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t BitSize = NarrowVT.getSizeInBits(); 15331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue ChainIn = Node->getOperand(0); 15341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Addr = Node->getOperand(1); 15351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue CmpVal = Node->getOperand(2); 15361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue SwapVal = Node->getOperand(3); 15371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineMemOperand *MMO = Node->getMemOperand(); 1538ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick SDLoc DL(Node); 15391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand EVT PtrVT = Addr.getValueType(); 15401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the address of the containing word. 15421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue AlignedAddr = DAG.getNode(ISD::AND, DL, PtrVT, Addr, 15431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(-4, PtrVT)); 15441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the number of bits that the word must be rotated left in order 15461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // to bring the field to the top bits of a GR32. 15471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue BitShift = DAG.getNode(ISD::SHL, DL, PtrVT, Addr, 15481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(3, PtrVT)); 15491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BitShift = DAG.getNode(ISD::TRUNCATE, DL, WideVT, BitShift); 15501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the complementing shift amount, for rotating a field in the top 15521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // bits back to its proper position. 15531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue NegBitShift = DAG.getNode(ISD::SUB, DL, WideVT, 15541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DAG.getConstant(0, WideVT), BitShift); 15551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Construct the ATOMIC_CMP_SWAPW node. 15571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDVTList VTList = DAG.getVTList(WideVT, MVT::Other); 15581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue Ops[] = { ChainIn, AlignedAddr, CmpVal, SwapVal, BitShift, 15591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NegBitShift, DAG.getConstant(BitSize, WideVT) }; 15601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SDValue AtomicOp = DAG.getMemIntrinsicNode(SystemZISD::ATOMIC_CMP_SWAPW, DL, 15611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand VTList, Ops, array_lengthof(Ops), 15621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NarrowVT, MMO); 15631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return AtomicOp; 15641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 15651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerSTACKSAVE(SDValue Op, 15671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 15681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = DAG.getMachineFunction(); 15691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true); 1570ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick return DAG.getCopyFromReg(Op.getOperand(0), SDLoc(Op), 15711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::R15D, Op.getValueType()); 15721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 15731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::lowerSTACKRESTORE(SDValue Op, 15751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 15761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = DAG.getMachineFunction(); 15771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MF.getInfo<SystemZMachineFunctionInfo>()->setManipulatesSP(true); 1578ac6d9bec671252dd1e596fa71180ff6b39d06b5dAndrew Trick return DAG.getCopyToReg(Op.getOperand(0), SDLoc(Op), 15791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::R15D, Op.getOperand(1)); 15801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 15811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 15821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSDValue SystemZTargetLowering::LowerOperation(SDValue Op, 15831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SelectionDAG &DAG) const { 15841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (Op.getOpcode()) { 15851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::BR_CC: 15861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerBR_CC(Op, DAG); 15871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SELECT_CC: 15881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerSELECT_CC(Op, DAG); 15891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::GlobalAddress: 15901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerGlobalAddress(cast<GlobalAddressSDNode>(Op), DAG); 15911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::GlobalTLSAddress: 15921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerGlobalTLSAddress(cast<GlobalAddressSDNode>(Op), DAG); 15931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::BlockAddress: 15941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerBlockAddress(cast<BlockAddressSDNode>(Op), DAG); 15951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::JumpTable: 15961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerJumpTable(cast<JumpTableSDNode>(Op), DAG); 15971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ConstantPool: 15981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerConstantPool(cast<ConstantPoolSDNode>(Op), DAG); 15991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::BITCAST: 16001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerBITCAST(Op, DAG); 16011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::VASTART: 16021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerVASTART(Op, DAG); 16031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::VACOPY: 16041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerVACOPY(Op, DAG); 16051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::DYNAMIC_STACKALLOC: 16061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerDYNAMIC_STACKALLOC(Op, DAG); 16071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::UMUL_LOHI: 16081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerUMUL_LOHI(Op, DAG); 16091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::SDIVREM: 16101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerSDIVREM(Op, DAG); 16111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::UDIVREM: 16121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerUDIVREM(Op, DAG); 16131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::OR: 16141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerOR(Op, DAG); 16151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_SWAP: 16161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_SWAPW); 16171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_ADD: 16181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_ADD); 16191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_SUB: 16201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_SUB); 16211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_AND: 16221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_AND); 16231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_OR: 16241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_OR); 16251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_XOR: 16261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_XOR); 16271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_NAND: 16281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_NAND); 16291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_MIN: 16301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_MIN); 16311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_MAX: 16321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_MAX); 16331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_UMIN: 16341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_UMIN); 16351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_LOAD_UMAX: 16361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_LOAD(Op, DAG, SystemZISD::ATOMIC_LOADW_UMAX); 16371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::ATOMIC_CMP_SWAP: 16381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerATOMIC_CMP_SWAP(Op, DAG); 16391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::STACKSAVE: 16401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerSTACKSAVE(Op, DAG); 16411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case ISD::STACKRESTORE: 16421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return lowerSTACKRESTORE(Op, DAG); 16431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 16441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Unexpected node to lower"); 16451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 16461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 16471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 16481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandconst char *SystemZTargetLowering::getTargetNodeName(unsigned Opcode) const { 16491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#define OPCODE(NAME) case SystemZISD::NAME: return "SystemZISD::" #NAME 16501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (Opcode) { 16511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(RET_FLAG); 16521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(CALL); 16531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(PCREL_WRAPPER); 16541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(CMP); 16551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(UCMP); 16561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(BR_CCMASK); 16571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(SELECT_CCMASK); 16581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ADJDYNALLOC); 16591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(EXTRACT_ACCESS); 16601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(UMUL_LOHI64); 16611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(SDIVREM64); 16621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(UDIVREM32); 16631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(UDIVREM64); 1664dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford OPCODE(MVC); 16651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_SWAPW); 16661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_ADD); 16671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_SUB); 16681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_AND); 16691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_OR); 16701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_XOR); 16711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_NAND); 16721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_MIN); 16731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_MAX); 16741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_UMIN); 16751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_LOADW_UMAX); 16761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand OPCODE(ATOMIC_CMP_SWAPW); 16771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 16781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return NULL; 16791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand#undef OPCODE 16801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 16811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 16821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 16831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Custom insertion 16841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand//===----------------------------------------------------------------------===// 16851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 16861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Create a new basic block after MBB. 16871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic MachineBasicBlock *emitBlockAfter(MachineBasicBlock *MBB) { 16881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = *MBB->getParent(); 16891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *NewMBB = MF.CreateMachineBasicBlock(MBB->getBasicBlock()); 16901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MF.insert(llvm::next(MachineFunction::iterator(MBB)), NewMBB); 16911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return NewMBB; 16921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 16931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 16941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Split MBB after MI and return the new block (the one that contains 16951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// instructions after MI). 16961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigandstatic MachineBasicBlock *splitBlockAfter(MachineInstr *MI, 16971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *MBB) { 16981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *NewMBB = emitBlockAfter(MBB); 16991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NewMBB->splice(NewMBB->begin(), MBB, 17001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm::next(MachineBasicBlock::iterator(MI)), 17011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->end()); 17021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand NewMBB->transferSuccessorsAndUpdatePHIs(MBB); 17031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return NewMBB; 17041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 17051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Implement EmitInstrWithCustomInserter for pseudo Select* instruction MI. 17071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandMachineBasicBlock * 17081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::emitSelect(MachineInstr *MI, 17091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *MBB) const { 17101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SystemZInstrInfo *TII = TM.getInstrInfo(); 17111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned DestReg = MI->getOperand(0).getReg(); 17131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned TrueReg = MI->getOperand(1).getReg(); 17141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned FalseReg = MI->getOperand(2).getReg(); 17156824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned CCValid = MI->getOperand(3).getImm(); 17166824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned CCMask = MI->getOperand(4).getImm(); 17171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DebugLoc DL = MI->getDebugLoc(); 17181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *StartMBB = MBB; 17201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *JoinMBB = splitBlockAfter(MI, MBB); 17211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *FalseMBB = emitBlockAfter(StartMBB); 17221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // StartMBB: 1724d50bcb2162a529534da42748ab4a418bfc9aaf06Richard Sandiford // BRC CCMask, JoinMBB 17251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fallthrough to FalseMBB 17261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = StartMBB; 17276824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 17286824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(CCValid).addImm(CCMask).addMBB(JoinMBB); 17291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(JoinMBB); 17301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(FalseMBB); 17311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // FalseMBB: 17331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fallthrough to JoinMBB 17341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = FalseMBB; 17351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(JoinMBB); 17361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // JoinMBB: 17381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %Result = phi [ %FalseReg, FalseMBB ], [ %TrueReg, StartMBB ] 17391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ... 17401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = JoinMBB; 17411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(*MBB, MBB->begin(), DL, TII->get(SystemZ::PHI), DestReg) 17421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(TrueReg).addMBB(StartMBB) 17431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(FalseReg).addMBB(FalseMBB); 17441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 17451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MI->eraseFromParent(); 17461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return JoinMBB; 17471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 17481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 1749722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford// Implement EmitInstrWithCustomInserter for pseudo CondStore* instruction MI. 1750722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford// StoreOpcode is the store to use and Invert says whether the store should 1751b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford// happen when the condition is false rather than true. If a STORE ON 1752b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford// CONDITION is available, STOCOpcode is its opcode, otherwise it is 0. 1753722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard SandifordMachineBasicBlock * 1754722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard SandifordSystemZTargetLowering::emitCondStore(MachineInstr *MI, 1755722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MachineBasicBlock *MBB, 1756b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford unsigned StoreOpcode, unsigned STOCOpcode, 1757b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford bool Invert) const { 1758722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford const SystemZInstrInfo *TII = TM.getInstrInfo(); 1759722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1760b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford unsigned SrcReg = MI->getOperand(0).getReg(); 1761b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford MachineOperand Base = MI->getOperand(1); 1762b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford int64_t Disp = MI->getOperand(2).getImm(); 1763b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford unsigned IndexReg = MI->getOperand(3).getReg(); 17646824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned CCValid = MI->getOperand(4).getImm(); 17656824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford unsigned CCMask = MI->getOperand(5).getImm(); 1766722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford DebugLoc DL = MI->getDebugLoc(); 1767722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1768722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford StoreOpcode = TII->getOpcodeForOffset(StoreOpcode, Disp); 1769722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1770b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford // Use STOCOpcode if possible. We could use different store patterns in 1771b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford // order to avoid matching the index register, but the performance trade-offs 1772b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford // might be more complicated in that case. 1773b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford if (STOCOpcode && !IndexReg && TM.getSubtargetImpl()->hasLoadStoreOnCond()) { 1774b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford if (Invert) 17756824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford CCMask ^= CCValid; 1776b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford BuildMI(*MBB, MI, DL, TII->get(STOCOpcode)) 1777b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford .addReg(SrcReg).addOperand(Base).addImm(Disp).addImm(CCMask); 1778b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford MI->eraseFromParent(); 1779b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return MBB; 1780b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford } 1781b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford 1782722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // Get the condition needed to branch around the store. 1783722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford if (!Invert) 17846824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford CCMask ^= CCValid; 1785722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1786722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MachineBasicBlock *StartMBB = MBB; 1787722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MachineBasicBlock *JoinMBB = splitBlockAfter(MI, MBB); 1788722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MachineBasicBlock *FalseMBB = emitBlockAfter(StartMBB); 1789722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1790722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // StartMBB: 1791722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // BRC CCMask, JoinMBB 1792722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // # fallthrough to FalseMBB 1793722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MBB = StartMBB; 17946824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 17956824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(CCValid).addImm(CCMask).addMBB(JoinMBB); 1796722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MBB->addSuccessor(JoinMBB); 1797722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MBB->addSuccessor(FalseMBB); 1798722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1799722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // FalseMBB: 1800722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // store %SrcReg, %Disp(%Index,%Base) 1801722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford // # fallthrough to JoinMBB 1802722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MBB = FalseMBB; 1803722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford BuildMI(MBB, DL, TII->get(StoreOpcode)) 1804722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford .addReg(SrcReg).addOperand(Base).addImm(Disp).addReg(IndexReg); 1805722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MBB->addSuccessor(JoinMBB); 1806722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 1807722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford MI->eraseFromParent(); 1808722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford return JoinMBB; 1809722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford} 1810722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 18111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Implement EmitInstrWithCustomInserter for pseudo ATOMIC_LOAD{,W}_* 18121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// or ATOMIC_SWAP{,W} instruction MI. BinOpcode is the instruction that 18131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// performs the binary operation elided by "*", or 0 for ATOMIC_SWAP{,W}. 18141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// BitSize is the width of the field in bits, or 0 if this is a partword 18151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// ATOMIC_LOADW_* or ATOMIC_SWAPW instruction, in which case the bitsize 18161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// is one of the operands. Invert says whether the field should be 18171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// inverted after performing BinOpcode (e.g. for NAND). 18181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandMachineBasicBlock * 18191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::emitAtomicLoadBinary(MachineInstr *MI, 18201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *MBB, 18211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned BinOpcode, 18221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned BitSize, 18231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool Invert) const { 18241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SystemZInstrInfo *TII = TM.getInstrInfo(); 18251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = *MBB->getParent(); 18261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineRegisterInfo &MRI = MF.getRegInfo(); 18271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool IsSubWord = (BitSize < 32); 18281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Extract the operands. Base can be a register or a frame index. 18301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Src2 can be a register or immediate. 18311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Dest = MI->getOperand(0).getReg(); 18321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineOperand Base = earlyUseOperand(MI->getOperand(1)); 18331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t Disp = MI->getOperand(2).getImm(); 18341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineOperand Src2 = earlyUseOperand(MI->getOperand(3)); 18351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned BitShift = (IsSubWord ? MI->getOperand(4).getReg() : 0); 18361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NegBitShift = (IsSubWord ? MI->getOperand(5).getReg() : 0); 18371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DebugLoc DL = MI->getDebugLoc(); 18381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 18391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BitSize = MI->getOperand(6).getImm(); 18401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Subword operations use 32-bit registers. 18421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const TargetRegisterClass *RC = (BitSize <= 32 ? 18431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &SystemZ::GR32BitRegClass : 18441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &SystemZ::GR64BitRegClass); 18451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned LOpcode = BitSize <= 32 ? SystemZ::L : SystemZ::LG; 18461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned CSOpcode = BitSize <= 32 ? SystemZ::CS : SystemZ::CSG; 18471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the right opcodes for the displacement. 18491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand LOpcode = TII->getOpcodeForOffset(LOpcode, Disp); 18501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CSOpcode = TII->getOpcodeForOffset(CSOpcode, Disp); 18511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(LOpcode && CSOpcode && "Displacement out of range"); 18521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Create virtual registers for temporary results. 18541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OrigVal = MRI.createVirtualRegister(RC); 18551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OldVal = MRI.createVirtualRegister(RC); 18561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NewVal = (BinOpcode || IsSubWord ? 18571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MRI.createVirtualRegister(RC) : Src2.getReg()); 18581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RotatedOldVal = (IsSubWord ? MRI.createVirtualRegister(RC) : OldVal); 18591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RotatedNewVal = (IsSubWord ? MRI.createVirtualRegister(RC) : NewVal); 18601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Insert a basic block for the main loop. 18621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *StartMBB = MBB; 18631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *DoneMBB = splitBlockAfter(MI, MBB); 18641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB); 18651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // StartMBB: 18671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ... 18681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %OrigVal = L Disp(%Base) 18691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to LoopMMB 18701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = StartMBB; 18711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(LOpcode), OrigVal) 18721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addOperand(Base).addImm(Disp).addReg(0); 18731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(LoopMBB); 18741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 18751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // LoopMBB: 18761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %OldVal = phi [ %OrigVal, StartMBB ], [ %Dest, LoopMBB ] 18771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RotatedOldVal = RLL %OldVal, 0(%BitShift) 18781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RotatedNewVal = OP %RotatedOldVal, %Src2 18791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %NewVal = RLL %RotatedNewVal, 0(%NegBitShift) 18801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %Dest = CS %OldVal, %NewVal, Disp(%Base) 18811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // JNE LoopMBB 18821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to DoneMMB 18831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = LoopMBB; 18841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::PHI), OldVal) 18851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OrigVal).addMBB(StartMBB) 18861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(Dest).addMBB(LoopMBB); 18871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 18881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RLL), RotatedOldVal) 18891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OldVal).addReg(BitShift).addImm(0); 18901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (Invert) { 18911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Perform the operation normally and then invert every bit of the field. 18921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Tmp = MRI.createVirtualRegister(RC); 18931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(BinOpcode), Tmp) 18941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedOldVal).addOperand(Src2); 18951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (BitSize < 32) 18961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // XILF with the upper BitSize bits set. 18971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::XILF32), RotatedNewVal) 18981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(Tmp).addImm(uint32_t(~0 << (32 - BitSize))); 18991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (BitSize == 32) 19001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // XILF with every bit set. 19011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::XILF32), RotatedNewVal) 19021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(Tmp).addImm(~uint32_t(0)); 19031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else { 19041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use LCGR and add -1 to the result, which is more compact than 19051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // an XILF, XILH pair. 19061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Tmp2 = MRI.createVirtualRegister(RC); 19071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::LCGR), Tmp2).addReg(Tmp); 19081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::AGHI), RotatedNewVal) 19091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(Tmp2).addImm(-1); 19101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 19111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } else if (BinOpcode) 19121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // A simply binary operation. 19131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(BinOpcode), RotatedNewVal) 19141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedOldVal).addOperand(Src2); 19151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand else if (IsSubWord) 19161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Use RISBG to rotate Src2 into position and use it to replace the 19171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // field in RotatedOldVal. 19181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RISBG32), RotatedNewVal) 19191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedOldVal).addReg(Src2.getReg()) 19201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addImm(32).addImm(31 + BitSize).addImm(32 - BitSize); 19211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 19221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RLL), NewVal) 19231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedNewVal).addReg(NegBitShift).addImm(0); 19241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(CSOpcode), Dest) 19251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OldVal).addReg(NewVal).addOperand(Base).addImm(Disp); 19266824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 19276824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(SystemZ::CCMASK_CS).addImm(SystemZ::CCMASK_CS_NE).addMBB(LoopMBB); 19281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(LoopMBB); 19291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(DoneMBB); 19301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MI->eraseFromParent(); 19321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DoneMBB; 19331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 19341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Implement EmitInstrWithCustomInserter for pseudo 19361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// ATOMIC_LOAD{,W}_{,U}{MIN,MAX} instruction MI. CompareOpcode is the 19371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// instruction that should be used to compare the current field with the 19381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// minimum or maximum value. KeepOldMask is the BRC condition-code mask 19391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// for when the current field should be kept. BitSize is the width of 19401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// the field in bits, or 0 if this is a partword ATOMIC_LOADW_* instruction. 19411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandMachineBasicBlock * 19421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::emitAtomicLoadMinMax(MachineInstr *MI, 19431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *MBB, 19441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned CompareOpcode, 19451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned KeepOldMask, 19461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned BitSize) const { 19471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SystemZInstrInfo *TII = TM.getInstrInfo(); 19481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = *MBB->getParent(); 19491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineRegisterInfo &MRI = MF.getRegInfo(); 19501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool IsSubWord = (BitSize < 32); 19511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Extract the operands. Base can be a register or a frame index. 19531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Dest = MI->getOperand(0).getReg(); 19541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineOperand Base = earlyUseOperand(MI->getOperand(1)); 19551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t Disp = MI->getOperand(2).getImm(); 19561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Src2 = MI->getOperand(3).getReg(); 19571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned BitShift = (IsSubWord ? MI->getOperand(4).getReg() : 0); 19581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NegBitShift = (IsSubWord ? MI->getOperand(5).getReg() : 0); 19591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DebugLoc DL = MI->getDebugLoc(); 19601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 19611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BitSize = MI->getOperand(6).getImm(); 19621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Subword operations use 32-bit registers. 19641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const TargetRegisterClass *RC = (BitSize <= 32 ? 19651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &SystemZ::GR32BitRegClass : 19661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand &SystemZ::GR64BitRegClass); 19671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned LOpcode = BitSize <= 32 ? SystemZ::L : SystemZ::LG; 19681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned CSOpcode = BitSize <= 32 ? SystemZ::CS : SystemZ::CSG; 19691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the right opcodes for the displacement. 19711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand LOpcode = TII->getOpcodeForOffset(LOpcode, Disp); 19721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand CSOpcode = TII->getOpcodeForOffset(CSOpcode, Disp); 19731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(LOpcode && CSOpcode && "Displacement out of range"); 19741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Create virtual registers for temporary results. 19761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OrigVal = MRI.createVirtualRegister(RC); 19771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OldVal = MRI.createVirtualRegister(RC); 19781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NewVal = MRI.createVirtualRegister(RC); 19791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RotatedOldVal = (IsSubWord ? MRI.createVirtualRegister(RC) : OldVal); 19801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RotatedAltVal = (IsSubWord ? MRI.createVirtualRegister(RC) : Src2); 19811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RotatedNewVal = (IsSubWord ? MRI.createVirtualRegister(RC) : NewVal); 19821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Insert 3 basic blocks for the loop. 19841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *StartMBB = MBB; 19851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *DoneMBB = splitBlockAfter(MI, MBB); 19861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB); 19871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *UseAltMBB = emitBlockAfter(LoopMBB); 19881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *UpdateMBB = emitBlockAfter(UseAltMBB); 19891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // StartMBB: 19911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ... 19921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %OrigVal = L Disp(%Base) 19931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to LoopMMB 19941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = StartMBB; 19951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(LOpcode), OrigVal) 19961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addOperand(Base).addImm(Disp).addReg(0); 19971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(LoopMBB); 19981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 19991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // LoopMBB: 20001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %OldVal = phi [ %OrigVal, StartMBB ], [ %Dest, UpdateMBB ] 20011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RotatedOldVal = RLL %OldVal, 0(%BitShift) 20021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // CompareOpcode %RotatedOldVal, %Src2 200344b486ed78c60b50aa14d4eed92ee828d4d44293Richard Sandiford // BRC KeepOldMask, UpdateMBB 20041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = LoopMBB; 20051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::PHI), OldVal) 20061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OrigVal).addMBB(StartMBB) 20071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(Dest).addMBB(UpdateMBB); 20081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 20091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RLL), RotatedOldVal) 20101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OldVal).addReg(BitShift).addImm(0); 20110416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford BuildMI(MBB, DL, TII->get(CompareOpcode)) 20120416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford .addReg(RotatedOldVal).addReg(Src2); 20130416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 20146824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(SystemZ::CCMASK_ICMP).addImm(KeepOldMask).addMBB(UpdateMBB); 20151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(UpdateMBB); 20161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(UseAltMBB); 20171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // UseAltMBB: 20191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RotatedAltVal = RISBG %RotatedOldVal, %Src2, 32, 31 + BitSize, 0 20201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to UpdateMMB 20211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = UseAltMBB; 20221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 20231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RISBG32), RotatedAltVal) 20241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedOldVal).addReg(Src2) 20251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addImm(32).addImm(31 + BitSize).addImm(0); 20261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(UpdateMBB); 20271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // UpdateMBB: 20291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RotatedNewVal = PHI [ %RotatedOldVal, LoopMBB ], 20301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // [ %RotatedAltVal, UseAltMBB ] 20311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %NewVal = RLL %RotatedNewVal, 0(%NegBitShift) 20321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %Dest = CS %OldVal, %NewVal, Disp(%Base) 20331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // JNE LoopMBB 20341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to DoneMMB 20351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = UpdateMBB; 20361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::PHI), RotatedNewVal) 20371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedOldVal).addMBB(LoopMBB) 20381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedAltVal).addMBB(UseAltMBB); 20391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (IsSubWord) 20401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RLL), NewVal) 20411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RotatedNewVal).addReg(NegBitShift).addImm(0); 20421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(CSOpcode), Dest) 20431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OldVal).addReg(NewVal).addOperand(Base).addImm(Disp); 20446824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 20456824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(SystemZ::CCMASK_CS).addImm(SystemZ::CCMASK_CS_NE).addMBB(LoopMBB); 20461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(LoopMBB); 20471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(DoneMBB); 20481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MI->eraseFromParent(); 20501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DoneMBB; 20511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 20521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Implement EmitInstrWithCustomInserter for pseudo ATOMIC_CMP_SWAPW 20541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// instruction MI. 20551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandMachineBasicBlock * 20561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::emitAtomicCmpSwapW(MachineInstr *MI, 20571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *MBB) const { 20581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SystemZInstrInfo *TII = TM.getInstrInfo(); 20591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = *MBB->getParent(); 20601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineRegisterInfo &MRI = MF.getRegInfo(); 20611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Extract the operands. Base can be a register or a frame index. 20631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Dest = MI->getOperand(0).getReg(); 20641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineOperand Base = earlyUseOperand(MI->getOperand(1)); 20651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t Disp = MI->getOperand(2).getImm(); 20661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OrigCmpVal = MI->getOperand(3).getReg(); 20671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OrigSwapVal = MI->getOperand(4).getReg(); 20681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned BitShift = MI->getOperand(5).getReg(); 20691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NegBitShift = MI->getOperand(6).getReg(); 20701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand int64_t BitSize = MI->getOperand(7).getImm(); 20711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DebugLoc DL = MI->getDebugLoc(); 20721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const TargetRegisterClass *RC = &SystemZ::GR32BitRegClass; 20741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Get the right opcodes for the displacement. 20761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned LOpcode = TII->getOpcodeForOffset(SystemZ::L, Disp); 20771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned CSOpcode = TII->getOpcodeForOffset(SystemZ::CS, Disp); 20781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand assert(LOpcode && CSOpcode && "Displacement out of range"); 20791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Create virtual registers for temporary results. 20811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OrigOldVal = MRI.createVirtualRegister(RC); 20821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned OldVal = MRI.createVirtualRegister(RC); 20831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned CmpVal = MRI.createVirtualRegister(RC); 20841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned SwapVal = MRI.createVirtualRegister(RC); 20851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned StoreVal = MRI.createVirtualRegister(RC); 20861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RetryOldVal = MRI.createVirtualRegister(RC); 20871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RetryCmpVal = MRI.createVirtualRegister(RC); 20881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned RetrySwapVal = MRI.createVirtualRegister(RC); 20891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // Insert 2 basic blocks for the loop. 20911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *StartMBB = MBB; 20921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *DoneMBB = splitBlockAfter(MI, MBB); 20931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *LoopMBB = emitBlockAfter(StartMBB); 20941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *SetMBB = emitBlockAfter(LoopMBB); 20951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 20961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // StartMBB: 20971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ... 20981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %OrigOldVal = L Disp(%Base) 20991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to LoopMMB 21001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = StartMBB; 21011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(LOpcode), OrigOldVal) 21021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addOperand(Base).addImm(Disp).addReg(0); 21031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(LoopMBB); 21041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // LoopMBB: 21061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %OldVal = phi [ %OrigOldVal, EntryBB ], [ %RetryOldVal, SetMBB ] 21071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %CmpVal = phi [ %OrigCmpVal, EntryBB ], [ %RetryCmpVal, SetMBB ] 21081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %SwapVal = phi [ %OrigSwapVal, EntryBB ], [ %RetrySwapVal, SetMBB ] 21091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %Dest = RLL %OldVal, BitSize(%BitShift) 21101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ^^ The low BitSize bits contain the field 21111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // of interest. 21121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RetryCmpVal = RISBG32 %CmpVal, %Dest, 32, 63-BitSize, 0 21131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ^^ Replace the upper 32-BitSize bits of the 21141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // comparison value with those that we loaded, 21151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // so that we can use a full word comparison. 21160416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford // CR %Dest, %RetryCmpVal 21170416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford // JNE DoneMBB 21181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # Fall through to SetMBB 21191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = LoopMBB; 21201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::PHI), OldVal) 21211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OrigOldVal).addMBB(StartMBB) 21221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RetryOldVal).addMBB(SetMBB); 21231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::PHI), CmpVal) 21241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OrigCmpVal).addMBB(StartMBB) 21251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RetryCmpVal).addMBB(SetMBB); 21261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::PHI), SwapVal) 21271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OrigSwapVal).addMBB(StartMBB) 21281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RetrySwapVal).addMBB(SetMBB); 21291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RLL), Dest) 21301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OldVal).addReg(BitShift).addImm(BitSize); 21311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RISBG32), RetryCmpVal) 21321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(CmpVal).addReg(Dest).addImm(32).addImm(63 - BitSize).addImm(0); 21330416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::CR)) 21340416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford .addReg(Dest).addReg(RetryCmpVal); 21350416e3c599c22dc656a1115ac983116ad0b2d9daRichard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 21366824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(SystemZ::CCMASK_ICMP) 21376824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(SystemZ::CCMASK_CMP_NE).addMBB(DoneMBB); 21381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(DoneMBB); 21391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(SetMBB); 21401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // SetMBB: 21421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RetrySwapVal = RISBG32 %SwapVal, %Dest, 32, 63-BitSize, 0 21431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ^^ Replace the upper 32-BitSize bits of the new 21441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // value with those that we loaded. 21451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %StoreVal = RLL %RetrySwapVal, -BitSize(%NegBitShift) 21461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // ^^ Rotate the new field to its proper position. 21471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // %RetryOldVal = CS %Dest, %StoreVal, Disp(%Base) 21481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // JNE LoopMBB 21491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand // # fall through to ExitMMB 21501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB = SetMBB; 21511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RISBG32), RetrySwapVal) 21521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(SwapVal).addReg(Dest).addImm(32).addImm(63 - BitSize).addImm(0); 21531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(SystemZ::RLL), StoreVal) 21541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(RetrySwapVal).addReg(NegBitShift).addImm(-BitSize); 21551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(MBB, DL, TII->get(CSOpcode), RetryOldVal) 21561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(OldVal).addReg(StoreVal).addOperand(Base).addImm(Disp); 21576824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford BuildMI(MBB, DL, TII->get(SystemZ::BRC)) 21586824f127f90197b26af93cf5d6c13b7941567e54Richard Sandiford .addImm(SystemZ::CCMASK_CS).addImm(SystemZ::CCMASK_CS_NE).addMBB(LoopMBB); 21591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(LoopMBB); 21601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MBB->addSuccessor(DoneMBB); 21611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MI->eraseFromParent(); 21631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return DoneMBB; 21641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 21651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// Emit an extension from a GR32 or GR64 to a GR128. ClearEven is true 21671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// if the high register of the GR128 value must be cleared or false if 21681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// it's "don't care". SubReg is subreg_odd32 when extending a GR32 21691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand// and subreg_odd when extending a GR64. 21701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandMachineBasicBlock * 21711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandSystemZTargetLowering::emitExt128(MachineInstr *MI, 21721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineBasicBlock *MBB, 21731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand bool ClearEven, unsigned SubReg) const { 21741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand const SystemZInstrInfo *TII = TM.getInstrInfo(); 21751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineFunction &MF = *MBB->getParent(); 21761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MachineRegisterInfo &MRI = MF.getRegInfo(); 21771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand DebugLoc DL = MI->getDebugLoc(); 21781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Dest = MI->getOperand(0).getReg(); 21801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Src = MI->getOperand(1).getReg(); 21811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned In128 = MRI.createVirtualRegister(&SystemZ::GR128BitRegClass); 21821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(*MBB, MI, DL, TII->get(TargetOpcode::IMPLICIT_DEF), In128); 21841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand if (ClearEven) { 21851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned NewIn128 = MRI.createVirtualRegister(&SystemZ::GR128BitRegClass); 21861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand unsigned Zero64 = MRI.createVirtualRegister(&SystemZ::GR64BitRegClass); 21871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(*MBB, MI, DL, TII->get(SystemZ::LLILL), Zero64) 21891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addImm(0); 21901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(*MBB, MI, DL, TII->get(TargetOpcode::INSERT_SUBREG), NewIn128) 21911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(In128).addReg(Zero64).addImm(SystemZ::subreg_high); 21921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand In128 = NewIn128; 21931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 21941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand BuildMI(*MBB, MI, DL, TII->get(TargetOpcode::INSERT_SUBREG), Dest) 21951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand .addReg(In128).addReg(Src).addImm(SubReg); 21961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 21971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand MI->eraseFromParent(); 21981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return MBB; 21991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 22001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2201dff0009d0ced62b92cb5900bc2203ec40142ba15Richard SandifordMachineBasicBlock * 2202dff0009d0ced62b92cb5900bc2203ec40142ba15Richard SandifordSystemZTargetLowering::emitMVCWrapper(MachineInstr *MI, 2203dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford MachineBasicBlock *MBB) const { 2204dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford const SystemZInstrInfo *TII = TM.getInstrInfo(); 2205dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford DebugLoc DL = MI->getDebugLoc(); 2206dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford 2207dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford MachineOperand DestBase = MI->getOperand(0); 2208dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford uint64_t DestDisp = MI->getOperand(1).getImm(); 2209dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford MachineOperand SrcBase = MI->getOperand(2); 2210dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford uint64_t SrcDisp = MI->getOperand(3).getImm(); 2211dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford uint64_t Length = MI->getOperand(4).getImm(); 2212dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford 2213dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford BuildMI(*MBB, MI, DL, TII->get(SystemZ::MVC)) 2214dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford .addOperand(DestBase).addImm(DestDisp).addImm(Length) 2215dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford .addOperand(SrcBase).addImm(SrcDisp); 2216dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford 2217dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford MI->eraseFromParent(); 2218dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford return MBB; 2219dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford} 2220dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford 22211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandMachineBasicBlock *SystemZTargetLowering:: 22221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich WeigandEmitInstrWithCustomInserter(MachineInstr *MI, MachineBasicBlock *MBB) const { 22231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand switch (MI->getOpcode()) { 22241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::Select32: 22251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::SelectF32: 22261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::Select64: 22271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::SelectF64: 22281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::SelectF128: 22291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitSelect(MI, MBB); 22301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 2231722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore8_32: 2232b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STC32, 0, false); 2233722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore8_32Inv: 2234b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STC32, 0, true); 2235722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore16_32: 2236b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STH32, 0, false); 2237722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore16_32Inv: 2238b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STH32, 0, true); 2239722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore32_32: 2240b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::ST32, SystemZ::STOC32, false); 2241722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore32_32Inv: 2242b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::ST32, SystemZ::STOC32, true); 2243722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore8: 2244b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STC, 0, false); 2245722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore8Inv: 2246b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STC, 0, true); 2247722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore16: 2248b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STH, 0, false); 2249722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore16Inv: 2250b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STH, 0, true); 2251722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore32: 2252b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::ST, SystemZ::STOC, false); 2253722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore32Inv: 2254b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::ST, SystemZ::STOC, true); 2255722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore64: 2256b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STG, SystemZ::STOCG, false); 2257722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStore64Inv: 2258b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STG, SystemZ::STOCG, true); 2259722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStoreF32: 2260b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STE, 0, false); 2261722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStoreF32Inv: 2262b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STE, 0, true); 2263722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStoreF64: 2264b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STD, 0, false); 2265722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford case SystemZ::CondStoreF64Inv: 2266b284e1bf08d24deb20b7deab71fce6f3034cc89aRichard Sandiford return emitCondStore(MI, MBB, SystemZ::STD, 0, true); 2267722e9e6d0a5b67d136be40bc015abc5b0b32f97bRichard Sandiford 22681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::AEXT128_64: 22691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitExt128(MI, MBB, false, SystemZ::subreg_low); 22701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ZEXT128_32: 22711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitExt128(MI, MBB, true, SystemZ::subreg_low32); 22721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ZEXT128_64: 22731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitExt128(MI, MBB, true, SystemZ::subreg_low); 22741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 22751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_SWAPW: 22761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, 0, 0); 22771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_SWAP_32: 22781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, 0, 32); 22791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_SWAP_64: 22801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, 0, 64); 22811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 22821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_AR: 22831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AR, 0); 22841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_AFI: 22851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AFI, 0); 22861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_AR: 22871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AR, 32); 22881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_AHI: 22891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AHI, 32); 22901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_AFI: 22911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AFI, 32); 22921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_AGR: 22931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AGR, 64); 22941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_AGHI: 22951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AGHI, 64); 22961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_AGFI: 22971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::AGFI, 64); 22981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 22991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_SR: 23001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::SR, 0); 23011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_SR: 23021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::SR, 32); 23031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_SGR: 23041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::SGR, 64); 23051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 23061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_NR: 23071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NR, 0); 23081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_NILH: 23091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILH32, 0); 23101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NR: 23111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NR, 32); 23121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILL32: 23131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILL32, 32); 23141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILH32: 23151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILH32, 32); 23161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILF32: 23171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILF32, 32); 23181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NGR: 23191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NGR, 64); 23201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILL: 23211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILL, 64); 23221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILH: 23231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILH, 64); 23241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NIHL: 23251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NIHL, 64); 23261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NIHH: 23271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NIHH, 64); 23281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILF: 23291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILF, 64); 23301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NIHF: 23311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NIHF, 64); 23321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 23331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_OR: 23341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OR, 0); 23351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_OILH: 23361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILH32, 0); 23371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OR: 23381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OR, 32); 23391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OILL32: 23401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILL32, 32); 23411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OILH32: 23421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILH32, 32); 23431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OILF32: 23441d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILF32, 32); 23451d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OGR: 23461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OGR, 64); 23471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OILL: 23481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILL, 64); 23491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OILH: 23501d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILH, 64); 23511d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OIHL: 23521d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OIHL, 64); 23531d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OIHH: 23541d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OIHH, 64); 23551d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OILF: 23561d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OILF, 64); 23571d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_OIHF: 23581d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::OIHF, 64); 23591d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 23601d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_XR: 23611d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XR, 0); 23621d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_XILF: 23631d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XILF32, 0); 23641d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_XR: 23651d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XR, 32); 23661d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_XILF32: 23671d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XILF32, 32); 23681d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_XGR: 23691d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XGR, 64); 23701d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_XILF: 23711d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XILF, 64); 23721d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_XIHF: 23731d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::XIHF, 64); 23741d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 23751d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_NRi: 23761d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NR, 0, true); 23771d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_NILHi: 23781d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILH32, 0, true); 23791d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NRi: 23801d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NR, 32, true); 23811d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILL32i: 23821d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILL32, 32, true); 23831d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILH32i: 23841d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILH32, 32, true); 23851d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILF32i: 23861d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILF32, 32, true); 23871d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NGRi: 23881d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NGR, 64, true); 23891d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILLi: 23901d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILL, 64, true); 23911d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILHi: 23921d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILH, 64, true); 23931d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NIHLi: 23941d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NIHL, 64, true); 23951d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NIHHi: 23961d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NIHH, 64, true); 23971d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NILFi: 23981d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NILF, 64, true); 23991d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_NIHFi: 24001d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadBinary(MI, MBB, SystemZ::NIHF, 64, true); 24011d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 24021d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_MIN: 24031d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CR, 24041d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_LE, 0); 24051d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_MIN_32: 24061d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CR, 24071d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_LE, 32); 24081d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_MIN_64: 24091d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CGR, 24101d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_LE, 64); 24111d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 24121d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_MAX: 24131d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CR, 24141d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_GE, 0); 24151d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_MAX_32: 24161d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CR, 24171d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_GE, 32); 24181d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_MAX_64: 24191d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CGR, 24201d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_GE, 64); 24211d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 24221d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_UMIN: 24231d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CLR, 24241d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_LE, 0); 24251d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_UMIN_32: 24261d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CLR, 24271d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_LE, 32); 24281d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_UMIN_64: 24291d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CLGR, 24301d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_LE, 64); 24311d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 24321d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOADW_UMAX: 24331d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CLR, 24341d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_GE, 0); 24351d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_UMAX_32: 24361d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CLR, 24371d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_GE, 32); 24381d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_LOAD_UMAX_64: 24391d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicLoadMinMax(MI, MBB, SystemZ::CLGR, 24401d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand SystemZ::CCMASK_CMP_GE, 64); 24411d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand 24421d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand case SystemZ::ATOMIC_CMP_SWAPW: 24431d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand return emitAtomicCmpSwapW(MI, MBB); 2444dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford case SystemZ::MVCWrapper: 2445dff0009d0ced62b92cb5900bc2203ec40142ba15Richard Sandiford return emitMVCWrapper(MI, MBB); 24461d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand default: 24471d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand llvm_unreachable("Unexpected instr type to insert"); 24481d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand } 24491d09d56fe1e3f3faadd4bf4ccf3e585ddb3c3b07Ulrich Weigand} 2450