lib/Target/X86/AsmPrinter/X86MCInstLower.cpp

   1 //===-- X86MCInstLower.cpp - Convert X86 MachineInstr to an MCInst --------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains code to lower X86 MachineInstrs to their corresponding
  11 // MCInst records.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "X86MCInstLower.h"
  16 #include "X86ATTAsmPrinter.h"
  17 #include "X86MCAsmInfo.h"
  18 #include "llvm/MC/MCContext.h"
  19 #include "llvm/MC/MCExpr.h"
  20 #include "llvm/MC/MCInst.h"
  21 #include "llvm/MC/MCStreamer.h"
  22 #include "llvm/Support/FormattedStream.h"
  23 #include "llvm/Support/Mangler.h"
  24 #include "llvm/ADT/SmallString.h"
  25 using namespace llvm;
  26
  27
  28 const X86Subtarget &X86MCInstLower::getSubtarget() const {
  29   return AsmPrinter.getSubtarget();
  30 }
  31
  32
  33 MCSymbol *X86MCInstLower::GetPICBaseSymbol() const {
  34   // FIXME: the actual label generated doesn't matter here!  Just mangle in
  35   // something unique (the function number) with Private prefix.
  36   SmallString<60> Name;
  37   raw_svector_ostream(Name) << AsmPrinter.MAI->getPrivateGlobalPrefix()
  38     << AsmPrinter.getFunctionNumber() << "$pb";
  39   return Ctx.GetOrCreateSymbol(Name.str());
  40 }
  41
  42
  43 /// LowerGlobalAddressOperand - Lower an MO_GlobalAddress operand to an
  44 /// MCOperand.
  45 MCSymbol *X86MCInstLower::
  46 GetGlobalAddressSymbol(const MachineOperand &MO) const {
  47   const GlobalValue *GV = MO.getGlobal();
  48
  49   bool isImplicitlyPrivate = false;
  50   if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB ||
  51       MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
  52       MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE ||
  53       MO.getTargetFlags() == X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE)
  54     isImplicitlyPrivate = true;
  55
  56   SmallString<128> Name;
  57   Mang->getNameWithPrefix(Name, GV, isImplicitlyPrivate);
  58
  59   if (getSubtarget().isTargetCygMing())
  60     AsmPrinter.DecorateCygMingName(Name, GV);
  61
  62   switch (MO.getTargetFlags()) {
  63   default: llvm_unreachable("Unknown target flag on GV operand");
  64   case X86II::MO_NO_FLAG:                // No flag.
  65   case X86II::MO_PIC_BASE_OFFSET:        // Doesn't modify symbol name.
  66     break;
  67   case X86II::MO_DLLIMPORT: {
  68     // Handle dllimport linkage.
  69     const char *Prefix = "__imp_";
  70     Name.insert(Name.begin(), Prefix, Prefix+strlen(Prefix));
  71     break;
  72   }
  73   case X86II::MO_DARWIN_NONLAZY:
  74   case X86II::MO_DARWIN_NONLAZY_PIC_BASE: {
  75     Name += "$non_lazy_ptr";
  76     MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str());
  77     MCSymbol *&StubSym = AsmPrinter.GVStubs[Sym];
  78     if (StubSym == 0) {
  79       Name.clear();
  80       Mang->getNameWithPrefix(Name, GV, false);
  81       StubSym = Ctx.GetOrCreateSymbol(Name.str());
  82     }
  83     return Sym;
  84   }
  85   case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE: {
  86     Name += "$non_lazy_ptr";
  87     MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str());
  88     MCSymbol *&StubSym = AsmPrinter.HiddenGVStubs[Sym];
  89     if (StubSym == 0) {
  90       Name.clear();
  91       Mang->getNameWithPrefix(Name, GV, false);
  92       StubSym = Ctx.GetOrCreateSymbol(Name.str());
  93     }
  94     return Sym;
  95   }
  96   case X86II::MO_DARWIN_STUB: {
  97     Name += "$stub";
  98     MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str());
  99     MCSymbol *&StubSym = AsmPrinter.FnStubs[Sym];
 100     if (StubSym == 0) {
 101       Name.clear();
 102       Mang->getNameWithPrefix(Name, GV, false);
 103       StubSym = Ctx.GetOrCreateSymbol(Name.str());
 104     }
 105     return Sym;
 106   }
 107   // FIXME: These probably should be a modifier on the symbol or something??
 108   case X86II::MO_TLSGD:     Name += "@TLSGD";     break;
 109   case X86II::MO_GOTTPOFF:  Name += "@GOTTPOFF";  break;
 110   case X86II::MO_INDNTPOFF: Name += "@INDNTPOFF"; break;
 111   case X86II::MO_TPOFF:     Name += "@TPOFF";     break;
 112   case X86II::MO_NTPOFF:    Name += "@NTPOFF";    break;
 113   case X86II::MO_GOTPCREL:  Name += "@GOTPCREL";  break;
 114   case X86II::MO_GOT:       Name += "@GOT";       break;
 115   case X86II::MO_GOTOFF:    Name += "@GOTOFF";    break;
 116   case X86II::MO_PLT:       Name += "@PLT";       break;
 117   }
 118
 119   return Ctx.GetOrCreateSymbol(Name.str());
 120 }
 121
 122 MCSymbol *X86MCInstLower::
 123 GetExternalSymbolSymbol(const MachineOperand &MO) const {
 124   SmallString<128> Name;
 125   Name += AsmPrinter.MAI->getGlobalPrefix();
 126   Name += MO.getSymbolName();
 127
 128   switch (MO.getTargetFlags()) {
 129   default: llvm_unreachable("Unknown target flag on GV operand");
 130   case X86II::MO_NO_FLAG:                // No flag.
 131   case X86II::MO_GOT_ABSOLUTE_ADDRESS:   // Doesn't modify symbol name.
 132   case X86II::MO_PIC_BASE_OFFSET:        // Doesn't modify symbol name.
 133     break;
 134   case X86II::MO_DLLIMPORT: {
 135     // Handle dllimport linkage.
 136     const char *Prefix = "__imp_";
 137     Name.insert(Name.begin(), Prefix, Prefix+strlen(Prefix));
 138     break;
 139   }
 140   case X86II::MO_DARWIN_STUB: {
 141     Name += "$stub";
 142     MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name.str());
 143     MCSymbol *&StubSym = AsmPrinter.FnStubs[Sym];
 144     if (StubSym == 0) {
 145       Name.erase(Name.end()-5, Name.end());
 146       StubSym = Ctx.GetOrCreateSymbol(Name.str());
 147     }
 148     return Sym;
 149   }
 150   // FIXME: These probably should be a modifier on the symbol or something??
 151   case X86II::MO_TLSGD:     Name += "@TLSGD";     break;
 152   case X86II::MO_GOTTPOFF:  Name += "@GOTTPOFF";  break;
 153   case X86II::MO_INDNTPOFF: Name += "@INDNTPOFF"; break;
 154   case X86II::MO_TPOFF:     Name += "@TPOFF";     break;
 155   case X86II::MO_NTPOFF:    Name += "@NTPOFF";    break;
 156   case X86II::MO_GOTPCREL:  Name += "@GOTPCREL";  break;
 157   case X86II::MO_GOT:       Name += "@GOT";       break;
 158   case X86II::MO_GOTOFF:    Name += "@GOTOFF";    break;
 159   case X86II::MO_PLT:       Name += "@PLT";       break;
 160   }
 161
 162   return Ctx.GetOrCreateSymbol(Name.str());
 163 }
 164
 165 MCSymbol *X86MCInstLower::GetJumpTableSymbol(const MachineOperand &MO) const {
 166   SmallString<256> Name;
 167   raw_svector_ostream(Name) << AsmPrinter.MAI->getPrivateGlobalPrefix() << "JTI"
 168     << AsmPrinter.getFunctionNumber() << '_' << MO.getIndex();
 169
 170   switch (MO.getTargetFlags()) {
 171   default:
 172     llvm_unreachable("Unknown target flag on GV operand");
 173   case X86II::MO_NO_FLAG:    // No flag.
 174   case X86II::MO_PIC_BASE_OFFSET:
 175   case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
 176   case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE:
 177     break;
 178     // FIXME: These probably should be a modifier on the symbol or something??
 179   case X86II::MO_TLSGD:     Name += "@TLSGD";     break;
 180   case X86II::MO_GOTTPOFF:  Name += "@GOTTPOFF";  break;
 181   case X86II::MO_INDNTPOFF: Name += "@INDNTPOFF"; break;
 182   case X86II::MO_TPOFF:     Name += "@TPOFF";     break;
 183   case X86II::MO_NTPOFF:    Name += "@NTPOFF";    break;
 184   case X86II::MO_GOTPCREL:  Name += "@GOTPCREL";  break;
 185   case X86II::MO_GOT:       Name += "@GOT";       break;
 186   case X86II::MO_GOTOFF:    Name += "@GOTOFF";    break;
 187   case X86II::MO_PLT:       Name += "@PLT";       break;
 188   }
 189
 190   // Create a symbol for the name.
 191   return Ctx.GetOrCreateSymbol(Name.str());
 192 }
 193
 194
 195 MCSymbol *X86MCInstLower::
 196 GetConstantPoolIndexSymbol(const MachineOperand &MO) const {
 197   SmallString<256> Name;
 198   raw_svector_ostream(Name) << AsmPrinter.MAI->getPrivateGlobalPrefix() << "CPI"
 199     << AsmPrinter.getFunctionNumber() << '_' << MO.getIndex();
 200
 201   switch (MO.getTargetFlags()) {
 202   default:
 203     llvm_unreachable("Unknown target flag on GV operand");
 204   case X86II::MO_NO_FLAG:    // No flag.
 205   case X86II::MO_PIC_BASE_OFFSET:
 206   case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
 207   case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE:
 208     break;
 209     // FIXME: These probably should be a modifier on the symbol or something??
 210   case X86II::MO_TLSGD:     Name += "@TLSGD";     break;
 211   case X86II::MO_GOTTPOFF:  Name += "@GOTTPOFF";  break;
 212   case X86II::MO_INDNTPOFF: Name += "@INDNTPOFF"; break;
 213   case X86II::MO_TPOFF:     Name += "@TPOFF";     break;
 214   case X86II::MO_NTPOFF:    Name += "@NTPOFF";    break;
 215   case X86II::MO_GOTPCREL:  Name += "@GOTPCREL";  break;
 216   case X86II::MO_GOT:       Name += "@GOT";       break;
 217   case X86II::MO_GOTOFF:    Name += "@GOTOFF";    break;
 218   case X86II::MO_PLT:       Name += "@PLT";       break;
 219   }
 220
 221   // Create a symbol for the name.
 222   return Ctx.GetOrCreateSymbol(Name.str());
 223 }
 224
 225 MCOperand X86MCInstLower::LowerSymbolOperand(const MachineOperand &MO,
 226                                              MCSymbol *Sym) const {
 227   // FIXME: We would like an efficient form for this, so we don't have to do a
 228   // lot of extra uniquing.
 229   const MCExpr *Expr = MCSymbolRefExpr::Create(Sym, Ctx);
 230
 231   switch (MO.getTargetFlags()) {
 232   default: llvm_unreachable("Unknown target flag on GV operand");
 233   case X86II::MO_NO_FLAG:    // No flag.
 234
 235   // These affect the name of the symbol, not any suffix.
 236   case X86II::MO_DARWIN_NONLAZY:
 237   case X86II::MO_DLLIMPORT:
 238   case X86II::MO_DARWIN_STUB:
 239   case X86II::MO_TLSGD:
 240   case X86II::MO_GOTTPOFF:
 241   case X86II::MO_INDNTPOFF:
 242   case X86II::MO_TPOFF:
 243   case X86II::MO_NTPOFF:
 244   case X86II::MO_GOTPCREL:
 245   case X86II::MO_GOT:
 246   case X86II::MO_GOTOFF:
 247   case X86II::MO_PLT:
 248     break;
 249   case X86II::MO_PIC_BASE_OFFSET:
 250   case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
 251   case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE:
 252     // Subtract the pic base.
 253     Expr = MCBinaryExpr::CreateSub(Expr,
 254                                MCSymbolRefExpr::Create(GetPICBaseSymbol(), Ctx),
 255                                    Ctx);
 256     break;
 257   }
 258
 259   if (!MO.isJTI() && MO.getOffset())
 260     Expr = MCBinaryExpr::CreateAdd(Expr,
 261                                    MCConstantExpr::Create(MO.getOffset(), Ctx),
 262                                    Ctx);
 263   return MCOperand::CreateExpr(Expr);
 264 }
 265
 266
 267
 268 static void lower_subreg32(MCInst *MI, unsigned OpNo) {
 269   // Convert registers in the addr mode according to subreg32.
 270   unsigned Reg = MI->getOperand(OpNo).getReg();
 271   if (Reg != 0)
 272     MI->getOperand(OpNo).setReg(getX86SubSuperRegister(Reg, MVT::i32));
 273 }
 274
 275 static void lower_lea64_32mem(MCInst *MI, unsigned OpNo) {
 276   // Convert registers in the addr mode according to subreg64.
 277   for (unsigned i = 0; i != 4; ++i) {
 278     if (!MI->getOperand(OpNo+i).isReg()) continue;
 279
 280     unsigned Reg = MI->getOperand(OpNo+i).getReg();
 281     if (Reg == 0) continue;
 282
 283     MI->getOperand(OpNo+i).setReg(getX86SubSuperRegister(Reg, MVT::i64));
 284   }
 285 }
 286
 287
 288
 289 void X86MCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
 290   OutMI.setOpcode(MI->getOpcode());
 291
 292   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 293     const MachineOperand &MO = MI->getOperand(i);
 294
 295     MCOperand MCOp;
 296     switch (MO.getType()) {
 297     default:
 298       MI->dump();
 299       llvm_unreachable("unknown operand type");
 300     case MachineOperand::MO_Register:
 301       MCOp = MCOperand::CreateReg(MO.getReg());
 302       break;
 303     case MachineOperand::MO_Immediate:
 304       MCOp = MCOperand::CreateImm(MO.getImm());
 305       break;
 306     case MachineOperand::MO_MachineBasicBlock:
 307       MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
 308                        AsmPrinter.GetMBBSymbol(MO.getMBB()->getNumber()), Ctx));
 309       break;
 310     case MachineOperand::MO_GlobalAddress:
 311       MCOp = LowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));
 312       break;
 313     case MachineOperand::MO_ExternalSymbol:
 314       MCOp = LowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
 315       break;
 316     case MachineOperand::MO_JumpTableIndex:
 317       MCOp = LowerSymbolOperand(MO, GetJumpTableSymbol(MO));
 318       break;
 319     case MachineOperand::MO_ConstantPoolIndex:
 320       MCOp = LowerSymbolOperand(MO, GetConstantPoolIndexSymbol(MO));
 321       break;
 322     }
 323
 324     OutMI.addOperand(MCOp);
 325   }
 326
 327   // Handle a few special cases to eliminate operand modifiers.
 328   switch (OutMI.getOpcode()) {
 329   case X86::LEA64_32r: // Handle 'subreg rewriting' for the lea64_32mem operand.
 330     lower_lea64_32mem(&OutMI, 1);
 331     break;
 332   case X86::MOV16r0:
 333     OutMI.setOpcode(X86::MOV32r0);
 334     lower_subreg32(&OutMI, 0);
 335     break;
 336   case X86::MOVZX16rr8:
 337     OutMI.setOpcode(X86::MOVZX32rr8);
 338     lower_subreg32(&OutMI, 0);
 339     break;
 340   case X86::MOVZX16rm8:
 341     OutMI.setOpcode(X86::MOVZX32rm8);
 342     lower_subreg32(&OutMI, 0);
 343     break;
 344   case X86::MOVSX16rr8:
 345     OutMI.setOpcode(X86::MOVSX32rr8);
 346     lower_subreg32(&OutMI, 0);
 347     break;
 348   case X86::MOVSX16rm8:
 349     OutMI.setOpcode(X86::MOVSX32rm8);
 350     lower_subreg32(&OutMI, 0);
 351     break;
 352   case X86::MOVZX64rr32:
 353     OutMI.setOpcode(X86::MOV32rr);
 354     lower_subreg32(&OutMI, 0);
 355     break;
 356   case X86::MOVZX64rm32:
 357     OutMI.setOpcode(X86::MOV32rm);
 358     lower_subreg32(&OutMI, 0);
 359     break;
 360   case X86::MOV64ri64i32:
 361     OutMI.setOpcode(X86::MOV32ri);
 362     lower_subreg32(&OutMI, 0);
 363     break;
 364   case X86::MOVZX64rr8:
 365     OutMI.setOpcode(X86::MOVZX32rr8);
 366     lower_subreg32(&OutMI, 0);
 367     break;
 368   case X86::MOVZX64rm8:
 369     OutMI.setOpcode(X86::MOVZX32rm8);
 370     lower_subreg32(&OutMI, 0);
 371     break;
 372   case X86::MOVZX64rr16:
 373     OutMI.setOpcode(X86::MOVZX32rr16);
 374     lower_subreg32(&OutMI, 0);
 375     break;
 376   case X86::MOVZX64rm16:
 377     OutMI.setOpcode(X86::MOVZX32rm16);
 378     lower_subreg32(&OutMI, 0);
 379     break;
 380   }
 381 }
 382
 383
 384
 385 void X86ATTAsmPrinter::
 386 printInstructionThroughMCStreamer(const MachineInstr *MI) {
 387   X86MCInstLower MCInstLowering(OutContext, Mang, *this);
 388   switch (MI->getOpcode()) {
 389   case TargetInstrInfo::DBG_LABEL:
 390   case TargetInstrInfo::EH_LABEL:
 391   case TargetInstrInfo::GC_LABEL:
 392     printLabel(MI);
 393     return;
 394   case TargetInstrInfo::INLINEASM:
 395     O << '\t';
 396     printInlineAsm(MI);
 397     return;
 398   case TargetInstrInfo::IMPLICIT_DEF:
 399     printImplicitDef(MI);
 400     return;
 401   case X86::MOVPC32r: {
 402     MCInst TmpInst;
 403     // This is a pseudo op for a two instruction sequence with a label, which
 404     // looks like:
 405     //     call "L1$pb"
 406     // "L1$pb":
 407     //     popl %esi
 408
 409     // Emit the call.
 410     MCSymbol *PICBase = MCInstLowering.GetPICBaseSymbol();
 411     TmpInst.setOpcode(X86::CALLpcrel32);
 412     // FIXME: We would like an efficient form for this, so we don't have to do a
 413     // lot of extra uniquing.
 414     TmpInst.addOperand(MCOperand::CreateExpr(MCSymbolRefExpr::Create(PICBase,
 415                                                                  OutContext)));
 416     printInstruction(&TmpInst);
 417     O << '\n';
 418
 419     // Emit the label.
 420     OutStreamer.EmitLabel(PICBase);
 421
 422     // popl $reg
 423     TmpInst.setOpcode(X86::POP32r);
 424     TmpInst.getOperand(0) = MCOperand::CreateReg(MI->getOperand(0).getReg());
 425     printInstruction(&TmpInst);
 426     return;
 427   }
 428
 429   case X86::ADD32ri: {
 430     // Lower the MO_GOT_ABSOLUTE_ADDRESS form of ADD32ri.
 431     if (MI->getOperand(2).getTargetFlags() != X86II::MO_GOT_ABSOLUTE_ADDRESS)
 432       break;
 433
 434     // Okay, we have something like:
 435     //  EAX = ADD32ri EAX, MO_GOT_ABSOLUTE_ADDRESS(@MYGLOBAL)
 436
 437     // For this, we want to print something like:
 438     //   MYGLOBAL + (. - PICBASE)
 439     // However, we can't generate a ".", so just emit a new label here and refer
 440     // to it.  We know that this operand flag occurs at most once per function.
 441     SmallString<64> Name;
 442     raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix()
 443       << "picbaseref" << getFunctionNumber();
 444     MCSymbol *DotSym = OutContext.GetOrCreateSymbol(Name.str());
 445     OutStreamer.EmitLabel(DotSym);
 446
 447     // Now that we have emitted the label, lower the complex operand expression.
 448     MCSymbol *OpSym = MCInstLowering.GetExternalSymbolSymbol(MI->getOperand(2));
 449
 450     const MCExpr *DotExpr = MCSymbolRefExpr::Create(DotSym, OutContext);
 451     const MCExpr *PICBase =
 452       MCSymbolRefExpr::Create(MCInstLowering.GetPICBaseSymbol(), OutContext);
 453     DotExpr = MCBinaryExpr::CreateSub(DotExpr, PICBase, OutContext);
 454
 455     DotExpr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(OpSym,OutContext),
 456                                       DotExpr, OutContext);
 457
 458     MCInst TmpInst;
 459     TmpInst.setOpcode(X86::ADD32ri);
 460     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(0).getReg()));
 461     TmpInst.addOperand(MCOperand::CreateReg(MI->getOperand(1).getReg()));
 462     TmpInst.addOperand(MCOperand::CreateExpr(DotExpr));
 463     printInstruction(&TmpInst);
 464     return;
 465   }
 466   }
 467
 468   MCInst TmpInst;
 469   MCInstLowering.Lower(MI, TmpInst);
 470
 471
 472   printInstruction(&TmpInst);
 473 }