Rebased PNaCl localmods in LLVM to 223109

lib/Target/X86/X86MCInstLower.cpp

 //===-- X86MCInstLower.cpp - Convert X86 MachineInstr to an MCInst --------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains code to lower X86 MachineInstrs to their corresponding
@@ skipping 671 matching lines @@
 void X86AsmPrinter::LowerTlsAddr(X86MCInstLower &MCInstLowering,
                                  const MachineInstr &MI) {
 
   bool is64Bits = MI.getOpcode() == X86::TLS_addr64 ||
                   MI.getOpcode() == X86::TLS_base_addr64;
 
   bool needsPadding = MI.getOpcode() == X86::TLS_addr64;
 
   MCContext &context = OutStreamer.getContext();
 
+  // @LOCALMOD-START
+  // TODO(dschuff): Instead of testing the target OS we should add (upstream) a
+  // method to one of the MC classes to test whether bundle alignment is enabled
+  // (currently only the AsmBackend has this, which can't be used when emitting
+  // asm files). That facility should be used here and in MCAsmStreamer.cpp
+  // (this should be done once we are unblocked from switching to gas by
+  // default, so we know exactly where we need it).
+  Triple TT(getSubtargetInfo().getTargetTriple());
+  const bool needsBundleLock = TT.getOS() == Triple::NaCl;
+  if (needsBundleLock)
+    OutStreamer.EmitBundleLock(false);
+  // @LOCALMOD-END
   if (needsPadding)
     EmitAndCountInstruction(MCInstBuilder(X86::DATA16_PREFIX));
 
   MCSymbolRefExpr::VariantKind SRVK;
   switch (MI.getOpcode()) {
     case X86::TLS_addr32:
     case X86::TLS_addr64:
       SRVK = MCSymbolRefExpr::VK_TLSGD;
       break;
     case X86::TLS_base_addr32:
@@ skipping 46 matching lines @@
   StringRef name = is64Bits ? "__tls_get_addr" : "___tls_get_addr";
   MCSymbol *tlsGetAddr = context.GetOrCreateSymbol(name);
   const MCSymbolRefExpr *tlsRef =
     MCSymbolRefExpr::Create(tlsGetAddr,
                             MCSymbolRefExpr::VK_PLT,
                             context);
 
   EmitAndCountInstruction(MCInstBuilder(is64Bits ? X86::CALL64pcrel32
                                                  : X86::CALLpcrel32)
                             .addExpr(tlsRef));
+  // @LOCALMOD-START
+  if (needsBundleLock)
+    OutStreamer.EmitBundleUnlock();
+  // @LOCALMOD-END
 }
 
 /// \brief Emit the optimal amount of multi-byte nops on X86.
 static void EmitNops(MCStreamer &OS, unsigned NumBytes, bool Is64Bit, const MCSubtargetInfo &STI) {
   // This works only for 64bit. For 32bit we have to do additional checking if
   // the CPU supports multi-byte nops.
   assert(Is64Bit && "EmitNops only supports X86-64");
   while (NumBytes) {
     unsigned Opc, BaseReg, ScaleVal, IndexReg, Displacement, SegmentReg;
     Opc = IndexReg = Displacement = SegmentReg = 0;
@@ skipping 296 matching lines @@
     if (MI->getOperand(2).getTargetFlags() != X86II::MO_GOT_ABSOLUTE_ADDRESS)
       break;
 
     // Okay, we have something like:
     //  EAX = ADD32ri EAX, MO_GOT_ABSOLUTE_ADDRESS(@MYGLOBAL)
 
     // For this, we want to print something like:
     //   MYGLOBAL + (. - PICBASE)
     // However, we can't generate a ".", so just emit a new label here and refer
     // to it.
+
+    // @LOCALMOD-START
+    // When using the gas assembler, emitting a new label and then using it in
+    // the difference expression gives the wrong value when the instruction
+    // following the label gets bundle padding added to it. (The label will
+    // point to the nop padding instead of the instruction, which works when
+    // jumping to the label, but not when calculating GOT addresses. See
+    // https://code.google.com/p/nativeclient/issues/detail?id=3982) For this
+    // case, just emit the instruction using the "." directly rather than going
+    // through all the MC layers. The LLVM assembler is smart enough to make the
+    // label point to the actual instruction rather than the nop, so this hack
+    // isn't necessary.
+    if (Subtarget->isTargetNaCl32() &&
+        OutStreamer.hasRawTextSupport()) {
+      std::string OS;
+      raw_string_ostream ROS(OS);
+      ROS << "\taddl\t$_GLOBAL_OFFSET_TABLE_+(.-" << *MF->getPICBaseSymbol()
+          << "), %"
+          << X86ATTInstPrinter::getRegisterName(MI->getOperand(0).getReg());
+      OutStreamer.EmitRawText(ROS.str());
+      return;
+    }
+    // @LOCALMOD-END
     MCSymbol *DotSym = OutContext.CreateTempSymbol();
     OutStreamer.EmitLabel(DotSym);
 
     // Now that we have emitted the label, lower the complex operand expression.
     MCSymbol *OpSym = MCInstLowering.GetSymbolFromOperand(MI->getOperand(2));
 
     const MCExpr *DotExpr = MCSymbolRefExpr::Create(DotSym, OutContext);
     const MCExpr *PICBase =
       MCSymbolRefExpr::Create(MF->getPICBaseSymbol(), OutContext);
     DotExpr = MCBinaryExpr::CreateSub(DotExpr, PICBase, OutContext);
@@ skipping 199 matching lines @@
     // Then flush the shadow so that we fill with nops before the call, not
     // after it.
     SMShadowTracker.emitShadowPadding(OutStreamer, getSubtargetInfo());
     // Then emit the call
     OutStreamer.EmitInstruction(TmpInst, getSubtargetInfo());
     return;
   }
 
   EmitAndCountInstruction(TmpInst);
 }