Rebased PNaCl localmods in LLVM to 223109

lib/Target/Mips/MipsISelLowering.cpp

 //===-- MipsISelLowering.cpp - Mips DAG Lowering Implementation -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the interfaces that Mips uses to lower LLVM code into a
@@ skipping 322 matching lines @@
   setOperationAction(ISD::FREM,              MVT::f32,   Expand);
   setOperationAction(ISD::FREM,              MVT::f64,   Expand);
 
   setOperationAction(ISD::EH_RETURN, MVT::Other, Custom);
 
   setOperationAction(ISD::VASTART,           MVT::Other, Custom);
   setOperationAction(ISD::VAARG,             MVT::Other, Custom);
   setOperationAction(ISD::VACOPY,            MVT::Other, Expand);
   setOperationAction(ISD::VAEND,             MVT::Other, Expand);
 
+  // @LOCALMOD-BEGIN
+  if (Subtarget.isTargetNaCl())
+    setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::Other, Custom);
+  else
+    setOperationAction(ISD::INTRINSIC_WO_CHAIN, MVT::i64, Custom);
+  // @LOCALMOD-END
+
   // Use the default for now
   setOperationAction(ISD::STACKSAVE,         MVT::Other, Expand);
   setOperationAction(ISD::STACKRESTORE,      MVT::Other, Expand);
 
   setOperationAction(ISD::ATOMIC_LOAD,       MVT::i32,    Expand);
   setOperationAction(ISD::ATOMIC_LOAD,       MVT::i64,    Expand);
   setOperationAction(ISD::ATOMIC_STORE,      MVT::i32,    Expand);
   setOperationAction(ISD::ATOMIC_STORE,      MVT::i64,    Expand);
 
   setInsertFencesForAtomic(true);
@@ skipping 1262 matching lines @@
   EVT Ty = Op.getValueType();
 
   if (getTargetMachine().getRelocationModel() != Reloc::PIC_ &&
       !Subtarget.isABI_N64())
     return getAddrNonPIC(N, Ty, DAG);
 
   return getAddrLocal(N, Ty, DAG,
                       Subtarget.isABI_N32() || Subtarget.isABI_N64());
 }
 
+// @LOCALMOD-BEGIN
+SDValue MipsTargetLowering::
+GetNaClThreadPointer(SelectionDAG &DAG, SDLoc DL) const {
+  EVT PtrVT = getPointerTy();
+  SDValue ThreadPointer;
+  if (llvm::TLSUseCall) {
+    unsigned PtrSize = PtrVT.getSizeInBits();
+    IntegerType *PtrTy = Type::getIntNTy(*DAG.getContext(), PtrSize);
+
+    // We must check whether the __nacl_read_tp is defined in the module because
+    // local and global pic functions are called differently. If the function
+    // is local the address is calculated with %got and %lo relocations.
+    // Otherwise, the address is calculated with %call16 relocation.
+    const Function *NaClReadTp = NULL;
+    const Module *M = DAG.getMachineFunction().getFunction()->getParent();
+    for (Module::const_iterator I = M->getFunctionList().begin(),
+           E = M->getFunctionList().end(); I != E; ++I) {
+      if (I->getName() == "__nacl_read_tp") {
+        NaClReadTp = I;
+        break;
+      }
+    }
+
+    SDValue TlsReadTp;
+    if (NaClReadTp == NULL)
+      TlsReadTp = DAG.getExternalSymbol("__nacl_read_tp", PtrVT);
+    else
+      TlsReadTp = DAG.getGlobalAddress(NaClReadTp, DL, PtrVT);
+
+    ArgListTy Args;
+    TargetLowering::CallLoweringInfo CLI(DAG);
+    CLI.setDebugLoc(DL).setChain(DAG.getEntryNode())
+      .setCallee(CallingConv::C, PtrTy, TlsReadTp, std::move(Args), 0);
+    std::pair<SDValue, SDValue> CallResult = LowerCallTo(CLI);
+
+    ThreadPointer = CallResult.first;
+  } else {
+    ThreadPointer = DAG.getCopyFromReg(DAG.getEntryNode(), DL,
+                                       Mips::T8, PtrVT);
+  }
+  return ThreadPointer;
+}
+// @LOCALMOD-END
+
 SDValue MipsTargetLowering::
 lowerGlobalTLSAddress(SDValue Op, SelectionDAG &DAG) const
 {
   // If the relocation model is PIC, use the General Dynamic TLS Model or
   // Local Dynamic TLS model, otherwise use the Initial Exec or
   // Local Exec TLS Model.
 
   GlobalAddressSDNode *GA = cast<GlobalAddressSDNode>(Op);
   SDLoc DL(GA);
   const GlobalValue *GV = GA->getGlobal();
   EVT PtrVT = getPointerTy();
 
   TLSModel::Model model = getTargetMachine().getTLSModel(GV);
 
+  // @LOCALMOD-BEGIN
+  if (Subtarget.isTargetNaCl()) {
+    SDVTList VTs = DAG.getVTList(MVT::i32);
+    SDValue TGAHi = DAG.getTargetGlobalAddress(GV, DL, MVT::i32, 0,
+                                                 MipsII::MO_TPREL_HI);
+    SDValue TGALo = DAG.getTargetGlobalAddress(GV, DL, MVT::i32, 0,
+                                                 MipsII::MO_TPREL_LO);
+    SDValue Hi = DAG.getNode(MipsISD::Hi, DL, VTs, TGAHi);
+    SDValue Lo = DAG.getNode(MipsISD::Lo, DL, MVT::i32, TGALo);
+    SDValue Offset = DAG.getNode(ISD::ADD, DL, MVT::i32, Hi, Lo);
+
+    SDValue ThreadPointer = GetNaClThreadPointer(DAG, DL);
+    // tprel_hi and tprel_lo relocations expect that thread pointer is offset
+    // by 0x7000 from the start of the TLS data area.
+    SDValue TPOffset = DAG.getConstant(0x7000, MVT::i32);
+    SDValue ThreadPointer2 = DAG.getNode(ISD::ADD, DL, PtrVT, ThreadPointer,
+                                         TPOffset);
+    return DAG.getNode(ISD::ADD, DL, PtrVT, ThreadPointer2, Offset);
+  }
+  // @LOCALMOD-END
+
   if (model == TLSModel::GeneralDynamic || model == TLSModel::LocalDynamic) {
     // General Dynamic and Local Dynamic TLS Model.
     unsigned Flag = (model == TLSModel::LocalDynamic) ? MipsII::MO_TLSLDM
                                                       : MipsII::MO_TLSGD;
 
     SDValue TGA = DAG.getTargetGlobalAddress(GV, DL, PtrVT, 0, Flag);
     SDValue Argument = DAG.getNode(MipsISD::Wrapper, DL, PtrVT,
                                    getGlobalReg(DAG, PtrVT), TGA);
     unsigned PtrSize = PtrVT.getSizeInBits();
     IntegerType *PtrTy = Type::getIntNTy(*DAG.getContext(), PtrSize);
@@ skipping 2064 matching lines @@
 
     // Mark the registers allocated.
     Size = RoundUpToAlignment(Size, RegSizeInBytes);
     for (unsigned I = FirstReg; Size > 0 && (I < IntArgRegs.size());
          Size -= RegSizeInBytes, ++I, ++NumRegs)
       State->AllocateReg(IntArgRegs[I], ShadowRegs[I]);
   }
 
   State->addInRegsParamInfo(FirstReg, FirstReg + NumRegs);
 }