lib/Target/X86/X86AsmPrinter.cpp

   1 //===-- X86AsmPrinter.cpp - Convert X86 LLVM IR to X86 assembly -----------===//
   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 the shared super class printer that converts from our internal
  11 // representation of machine-dependent LLVM code to Intel and AT&T format
  12 // assembly language.
  13 // This printer is the output mechanism used by `llc'.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "X86AsmPrinter.h"
  18 #include "X86ATTAsmPrinter.h"
  19 #include "X86COFF.h"
  20 #include "X86IntelAsmPrinter.h"
  21 #include "X86MachineFunctionInfo.h"
  22 #include "X86Subtarget.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/CallingConv.h"
  25 #include "llvm/Constants.h"
  26 #include "llvm/Module.h"
  27 #include "llvm/DerivedTypes.h"
  28 #include "llvm/ParameterAttributes.h"
  29 #include "llvm/Type.h"
  30 #include "llvm/Assembly/Writer.h"
  31 #include "llvm/Support/Mangler.h"
  32 #include "llvm/Target/TargetAsmInfo.h"
  33 #include "llvm/Target/TargetOptions.h"
  34 using namespace llvm;
  35
  36 static X86MachineFunctionInfo calculateFunctionInfo(const Function *F,
  37                                                     const TargetData *TD) {
  38   X86MachineFunctionInfo Info;
  39   uint64_t Size = 0;
  40
  41   switch (F->getCallingConv()) {
  42   case CallingConv::X86_StdCall:
  43     Info.setDecorationStyle(StdCall);
  44     break;
  45   case CallingConv::X86_FastCall:
  46     Info.setDecorationStyle(FastCall);
  47     break;
  48   default:
  49     return Info;
  50   }
  51
  52   unsigned argNum = 1;
  53   for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
  54        AI != AE; ++AI, ++argNum) {
  55     const Type* Ty = AI->getType();
  56
  57     // 'Dereference' type in case of byval parameter attribute
  58     if (F->paramHasAttr(argNum, ParamAttr::ByVal))
  59       Ty = cast<PointerType>(Ty)->getElementType();
  60
  61     // Size should be aligned to DWORD boundary
  62     Size += ((TD->getABITypeSize(Ty) + 3)/4)*4;
  63   }
  64
  65   // We're not supporting tooooo huge arguments :)
  66   Info.setBytesToPopOnReturn((unsigned int)Size);
  67   return Info;
  68 }
  69
  70
  71 /// decorateName - Query FunctionInfoMap and use this information for various
  72 /// name decoration.
  73 void X86SharedAsmPrinter::decorateName(std::string &Name,
  74                                        const GlobalValue *GV) {
  75   const Function *F = dyn_cast<Function>(GV);
  76   if (!F) return;
  77
  78   // We don't want to decorate non-stdcall or non-fastcall functions right now
  79   unsigned CC = F->getCallingConv();
  80   if (CC != CallingConv::X86_StdCall && CC != CallingConv::X86_FastCall)
  81     return;
  82
  83   // Decorate names only when we're targeting Cygwin/Mingw32 targets
  84   if (!Subtarget->isTargetCygMing())
  85     return;
  86
  87   FMFInfoMap::const_iterator info_item = FunctionInfoMap.find(F);
  88
  89   const X86MachineFunctionInfo *Info;
  90   if (info_item == FunctionInfoMap.end()) {
  91     // Calculate apropriate function info and populate map
  92     FunctionInfoMap[F] = calculateFunctionInfo(F, TM.getTargetData());
  93     Info = &FunctionInfoMap[F];
  94   } else {
  95     Info = &info_item->second;
  96   }
  97
  98   const FunctionType *FT = F->getFunctionType();
  99   switch (Info->getDecorationStyle()) {
 100   case None:
 101     break;
 102   case StdCall:
 103     // "Pure" variadic functions do not receive @0 suffix.
 104     if (!FT->isVarArg() || (FT->getNumParams() == 0) ||
 105         (FT->getNumParams() == 1 && F->isStructReturn()))
 106       Name += '@' + utostr_32(Info->getBytesToPopOnReturn());
 107     break;
 108   case FastCall:
 109     // "Pure" variadic functions do not receive @0 suffix.
 110     if (!FT->isVarArg() || (FT->getNumParams() == 0) ||
 111         (FT->getNumParams() == 1 && F->isStructReturn()))
 112       Name += '@' + utostr_32(Info->getBytesToPopOnReturn());
 113
 114     if (Name[0] == '_') {
 115       Name[0] = '@';
 116     } else {
 117       Name = '@' + Name;
 118     }
 119     break;
 120   default:
 121     assert(0 && "Unsupported DecorationStyle");
 122   }
 123 }
 124
 125 /// doInitialization
 126 bool X86SharedAsmPrinter::doInitialization(Module &M) {
 127   if (TAI->doesSupportDebugInformation()) {
 128     // Emit initial debug information.
 129     DW.BeginModule(&M);
 130   }
 131
 132   bool Result = AsmPrinter::doInitialization(M);
 133
 134   // Darwin wants symbols to be quoted if they have complex names.
 135   if (Subtarget->isTargetDarwin())
 136     Mang->setUseQuotes(true);
 137
 138   return Result;
 139 }
 140
 141 /// PrintUnmangledNameSafely - Print out the printable characters in the name.
 142 /// Don't print things like \n or \0.
 143 static void PrintUnmangledNameSafely(const Value *V, std::ostream &OS) {
 144   for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
 145        Name != E; ++Name)
 146     if (isprint(*Name))
 147       OS << *Name;
 148 }
 149
 150 bool X86SharedAsmPrinter::doFinalization(Module &M) {
 151   // Note: this code is not shared by the Intel printer as it is too different
 152   // from how MASM does things.  When making changes here don't forget to look
 153   // at X86IntelAsmPrinter::doFinalization().
 154   const TargetData *TD = TM.getTargetData();
 155
 156   // Print out module-level global variables here.
 157   for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
 158        I != E; ++I) {
 159     if (!I->hasInitializer())
 160       continue;   // External global require no code
 161
 162     // Check to see if this is a special global used by LLVM, if so, emit it.
 163     if (EmitSpecialLLVMGlobal(I)) {
 164       if (Subtarget->isTargetDarwin() &&
 165           TM.getRelocationModel() == Reloc::Static) {
 166         if (I->getName() == "llvm.global_ctors")
 167           O << ".reference .constructors_used\n";
 168         else if (I->getName() == "llvm.global_dtors")
 169           O << ".reference .destructors_used\n";
 170       }
 171       continue;
 172     }
 173
 174     std::string name = Mang->getValueName(I);
 175     Constant *C = I->getInitializer();
 176     const Type *Type = C->getType();
 177     unsigned Size = TD->getABITypeSize(Type);
 178     unsigned Align = TD->getPreferredAlignmentLog(I);
 179
 180     if (I->hasHiddenVisibility()) {
 181       if (const char *Directive = TAI->getHiddenDirective())
 182         O << Directive << name << "\n";
 183     } else if (I->hasProtectedVisibility()) {
 184       if (const char *Directive = TAI->getProtectedDirective())
 185         O << Directive << name << "\n";
 186     }
 187
 188     if (Subtarget->isTargetELF())
 189       O << "\t.type\t" << name << ",@object\n";
 190
 191     if (C->isNullValue() && !I->hasSection()) {
 192       if (I->hasExternalLinkage()) {
 193         if (const char *Directive = TAI->getZeroFillDirective()) {
 194           O << "\t.globl " << name << "\n";
 195           O << Directive << "__DATA, __common, " << name << ", "
 196             << Size << ", " << Align << "\n";
 197           continue;
 198         }
 199       }
 200
 201       if (!I->isThreadLocal() &&
 202           (I->hasInternalLinkage() || I->hasWeakLinkage() ||
 203            I->hasLinkOnceLinkage())) {
 204         if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
 205         if (!NoZerosInBSS && TAI->getBSSSection())
 206           SwitchToDataSection(TAI->getBSSSection(), I);
 207         else
 208           SwitchToDataSection(TAI->getDataSection(), I);
 209         if (TAI->getLCOMMDirective() != NULL) {
 210           if (I->hasInternalLinkage()) {
 211             O << TAI->getLCOMMDirective() << name << "," << Size;
 212             if (Subtarget->isTargetDarwin())
 213               O << "," << Align;
 214           } else {
 215             O << TAI->getCOMMDirective()  << name << "," << Size;
 216
 217             // Leopard and above support aligned common symbols.
 218             if (Subtarget->getDarwinVers() >= 9)
 219               O << "," << Align;
 220           }
 221         } else {
 222           if (!Subtarget->isTargetCygMing()) {
 223             if (I->hasInternalLinkage())
 224               O << "\t.local\t" << name << "\n";
 225           }
 226           O << TAI->getCOMMDirective()  << name << "," << Size;
 227           if (TAI->getCOMMDirectiveTakesAlignment())
 228             O << "," << (TAI->getAlignmentIsInBytes() ? (1 << Align) : Align);
 229         }
 230         O << "\t\t" << TAI->getCommentString() << " ";
 231         PrintUnmangledNameSafely(I, O);
 232         O << "\n";
 233         continue;
 234       }
 235     }
 236
 237     switch (I->getLinkage()) {
 238     case GlobalValue::LinkOnceLinkage:
 239     case GlobalValue::WeakLinkage:
 240       if (Subtarget->isTargetDarwin()) {
 241         O << "\t.globl " << name << "\n"
 242           << TAI->getWeakDefDirective() << name << "\n";
 243         SwitchToDataSection("\t.section __DATA,__datacoal_nt,coalesced", I);
 244       } else if (Subtarget->isTargetCygMing()) {
 245         std::string SectionName(".section\t.data$linkonce." +
 246                                 name +
 247                                 ",\"aw\"");
 248         SwitchToDataSection(SectionName.c_str(), I);
 249         O << "\t.globl\t" << name << "\n"
 250           << "\t.linkonce same_size\n";
 251       } else {
 252         std::string SectionName("\t.section\t.llvm.linkonce.d." +
 253                                 name +
 254                                 ",\"aw\",@progbits");
 255         SwitchToDataSection(SectionName.c_str(), I);
 256         O << "\t.weak\t" << name << "\n";
 257       }
 258       break;
 259     case GlobalValue::DLLExportLinkage:
 260       DLLExportedGVs.insert(Mang->makeNameProper(I->getName(),""));
 261       // FALL THROUGH
 262     case GlobalValue::AppendingLinkage:
 263       // FIXME: appending linkage variables should go into a section of
 264       // their name or something.  For now, just emit them as external.
 265     case GlobalValue::ExternalLinkage:
 266       // If external or appending, declare as a global symbol
 267       O << "\t.globl " << name << "\n";
 268       // FALL THROUGH
 269     case GlobalValue::InternalLinkage: {
 270       if (I->isConstant()) {
 271         const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
 272         if (TAI->getCStringSection() && CVA && CVA->isCString()) {
 273           SwitchToDataSection(TAI->getCStringSection(), I);
 274           break;
 275         }
 276       }
 277       // FIXME: special handling for ".ctors" & ".dtors" sections
 278       if (I->hasSection() &&
 279           (I->getSection() == ".ctors" ||
 280            I->getSection() == ".dtors")) {
 281         std::string SectionName = ".section " + I->getSection();
 282
 283         if (Subtarget->isTargetCygMing()) {
 284           SectionName += ",\"aw\"";
 285         } else {
 286           assert(!Subtarget->isTargetDarwin());
 287           SectionName += ",\"aw\",@progbits";
 288         }
 289         SwitchToDataSection(SectionName.c_str());
 290       } else if (I->hasSection() && Subtarget->isTargetDarwin()) {
 291         // Honor all section names on Darwin; ObjC uses this
 292         std::string SectionName = ".section " + I->getSection();
 293         SwitchToDataSection(SectionName.c_str());
 294       } else {
 295         if (C->isNullValue() && !NoZerosInBSS && TAI->getBSSSection())
 296           SwitchToDataSection(I->isThreadLocal() ? TAI->getTLSBSSSection() :
 297                               TAI->getBSSSection(), I);
 298         else if (!I->isConstant())
 299           SwitchToDataSection(I->isThreadLocal() ? TAI->getTLSDataSection() :
 300                               TAI->getDataSection(), I);
 301         else if (I->isThreadLocal())
 302           SwitchToDataSection(TAI->getTLSDataSection());
 303         else {
 304           // Read-only data.
 305           bool HasReloc = C->ContainsRelocations();
 306           if (HasReloc &&
 307               Subtarget->isTargetDarwin() &&
 308               TM.getRelocationModel() != Reloc::Static)
 309             SwitchToDataSection("\t.const_data\n");
 310           else if (!HasReloc && Size == 4 &&
 311                    TAI->getFourByteConstantSection())
 312             SwitchToDataSection(TAI->getFourByteConstantSection(), I);
 313           else if (!HasReloc && Size == 8 &&
 314                    TAI->getEightByteConstantSection())
 315             SwitchToDataSection(TAI->getEightByteConstantSection(), I);
 316           else if (!HasReloc && Size == 16 &&
 317                    TAI->getSixteenByteConstantSection())
 318             SwitchToDataSection(TAI->getSixteenByteConstantSection(), I);
 319           else if (TAI->getReadOnlySection())
 320             SwitchToDataSection(TAI->getReadOnlySection(), I);
 321           else
 322             SwitchToDataSection(TAI->getDataSection(), I);
 323         }
 324       }
 325
 326       break;
 327     }
 328     default:
 329       assert(0 && "Unknown linkage type!");
 330     }
 331
 332     EmitAlignment(Align, I);
 333     O << name << ":\t\t\t\t" << TAI->getCommentString() << " ";
 334     PrintUnmangledNameSafely(I, O);
 335     O << "\n";
 336     if (TAI->hasDotTypeDotSizeDirective())
 337       O << "\t.size\t" << name << ", " << Size << "\n";
 338     // If the initializer is a extern weak symbol, remember to emit the weak
 339     // reference!
 340     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C))
 341       if (GV->hasExternalWeakLinkage())
 342         ExtWeakSymbols.insert(GV);
 343
 344     EmitGlobalConstant(C);
 345   }
 346
 347   // Output linker support code for dllexported globals
 348   if (!DLLExportedGVs.empty()) {
 349     SwitchToDataSection(".section .drectve");
 350   }
 351
 352   for (std::set<std::string>::iterator i = DLLExportedGVs.begin(),
 353          e = DLLExportedGVs.end();
 354          i != e; ++i) {
 355     O << "\t.ascii \" -export:" << *i << ",data\"\n";
 356   }
 357
 358   if (!DLLExportedFns.empty()) {
 359     SwitchToDataSection(".section .drectve");
 360   }
 361
 362   for (std::set<std::string>::iterator i = DLLExportedFns.begin(),
 363          e = DLLExportedFns.end();
 364          i != e; ++i) {
 365     O << "\t.ascii \" -export:" << *i << "\"\n";
 366   }
 367
 368   if (Subtarget->isTargetDarwin()) {
 369     SwitchToDataSection("");
 370
 371     // Output stubs for dynamically-linked functions
 372     unsigned j = 1;
 373     for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
 374          i != e; ++i, ++j) {
 375       SwitchToDataSection("\t.section __IMPORT,__jump_table,symbol_stubs,"
 376                           "self_modifying_code+pure_instructions,5", 0);
 377       O << "L" << *i << "$stub:\n";
 378       O << "\t.indirect_symbol " << *i << "\n";
 379       O << "\thlt ; hlt ; hlt ; hlt ; hlt\n";
 380     }
 381
 382     O << "\n";
 383
 384     if (ExceptionHandling && TAI->doesSupportExceptionHandling() && MMI &&
 385         !Subtarget->is64Bit()) {
 386       // Add the (possibly multiple) personalities to the set of global values.
 387       const std::vector<Function *>& Personalities = MMI->getPersonalities();
 388
 389       for (std::vector<Function *>::const_iterator I = Personalities.begin(),
 390              E = Personalities.end(); I != E; ++I)
 391         if (*I) GVStubs.insert("_" + (*I)->getName());
 392     }
 393
 394     // Output stubs for external and common global variables.
 395     if (!GVStubs.empty())
 396       SwitchToDataSection(
 397                     "\t.section __IMPORT,__pointers,non_lazy_symbol_pointers");
 398     for (std::set<std::string>::iterator i = GVStubs.begin(), e = GVStubs.end();
 399          i != e; ++i) {
 400       O << "L" << *i << "$non_lazy_ptr:\n";
 401       O << "\t.indirect_symbol " << *i << "\n";
 402       O << "\t.long\t0\n";
 403     }
 404
 405     // Emit final debug information.
 406     DW.EndModule();
 407
 408     // Funny Darwin hack: This flag tells the linker that no global symbols
 409     // contain code that falls through to other global symbols (e.g. the obvious
 410     // implementation of multiple entry points).  If this doesn't occur, the
 411     // linker can safely perform dead code stripping.  Since LLVM never
 412     // generates code that does this, it is always safe to set.
 413     O << "\t.subsections_via_symbols\n";
 414   } else if (Subtarget->isTargetCygMing()) {
 415     // Emit type information for external functions
 416     for (std::set<std::string>::iterator i = FnStubs.begin(), e = FnStubs.end();
 417          i != e; ++i) {
 418       O << "\t.def\t " << *i
 419         << ";\t.scl\t" << COFF::C_EXT
 420         << ";\t.type\t" << (COFF::DT_FCN << COFF::N_BTSHFT)
 421         << ";\t.endef\n";
 422     }
 423
 424     // Emit final debug information.
 425     DW.EndModule();
 426   } else if (Subtarget->isTargetELF()) {
 427     // Emit final debug information.
 428     DW.EndModule();
 429   }
 430
 431   return AsmPrinter::doFinalization(M);
 432 }
 433
 434 /// createX86CodePrinterPass - Returns a pass that prints the X86 assembly code
 435 /// for a MachineFunction to the given output stream, using the given target
 436 /// machine description.
 437 ///
 438 FunctionPass *llvm::createX86CodePrinterPass(std::ostream &o,
 439                                              X86TargetMachine &tm) {
 440   const X86Subtarget *Subtarget = &tm.getSubtarget<X86Subtarget>();
 441
 442   if (Subtarget->isFlavorIntel()) {
 443     return new X86IntelAsmPrinter(o, tm, tm.getTargetAsmInfo());
 444   } else {
 445     return new X86ATTAsmPrinter(o, tm, tm.getTargetAsmInfo());
 446   }
 447 }