AsmPrinter.cpp revision 1947f242d40227d36440a2702a0a612c8077d72e
1a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner//===-- AsmPrinter.cpp - Common AsmPrinter code ---------------------------===// 2a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// 3a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// The LLVM Compiler Infrastructure 4a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// 8a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner//===----------------------------------------------------------------------===// 9a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// 10a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// This file implements the AsmPrinter class. 11a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner// 12a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner//===----------------------------------------------------------------------===// 13a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 14932f022b826c7b0b821c6a5369e18e4ebdceeb4cEvan Cheng#include "llvm/CodeGen/AsmPrinter.h" 15246ae0dcf750401ee84e1319ebe0b790744097a5Evan Cheng#include "llvm/Assembly/Writer.h" 168cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman#include "llvm/DerivedTypes.h" 17a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner#include "llvm/Constants.h" 18450de393acdf4be89db8558522b04d8111e4562bChris Lattner#include "llvm/Module.h" 1945111d160cf0910030eeb6a949c69273502e5ad5Chris Lattner#include "llvm/CodeGen/DwarfWriter.h" 205eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen#include "llvm/CodeGen/GCMetadataPrinter.h" 213b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 221924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene#include "llvm/CodeGen/MachineFrameInfo.h" 23fe37ab335be5632eab561d49984c95cb06b946d4David Greene#include "llvm/CodeGen/MachineFunction.h" 2437efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 25b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene#include "llvm/CodeGen/MachineLoopInfo.h" 2684bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 27cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis#include "llvm/Analysis/DebugInfo.h" 282b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner#include "llvm/MC/MCContext.h" 2952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner#include "llvm/MC/MCExpr.h" 303ac1ab835caacdeebbd0d7b4d69160f283928d21David Greene#include "llvm/MC/MCInst.h" 31a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner#include "llvm/MC/MCSection.h" 32a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner#include "llvm/MC/MCStreamer.h" 337cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner#include "llvm/MC/MCSymbol.h" 3442bf74be1402df7409efbea089310d4c276fde37Evan Cheng#include "llvm/Support/CommandLine.h" 357d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 360fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner#include "llvm/Support/Format.h" 37014700c1a8cba203fd21ff129426ba8a426ab244David Greene#include "llvm/Support/FormattedStream.h" 38af76e592c7f9deff0e55c13dbb4a34f07f1c7f64Chris Lattner#include "llvm/MC/MCAsmInfo.h" 3945111d160cf0910030eeb6a949c69273502e5ad5Chris Lattner#include "llvm/Target/Mangler.h" 4007000c6f01d8f57170f2d4c77a86d934bdc5c696Owen Anderson#include "llvm/Target/TargetData.h" 411924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene#include "llvm/Target/TargetInstrInfo.h" 420336fdba858830d515bf53ac29b8e5ff24dfa823Chris Lattner#include "llvm/Target/TargetLowering.h" 43f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner#include "llvm/Target/TargetLoweringObjectFile.h" 446547e406cf934346db7a206b61bcf09635afff0dEvan Cheng#include "llvm/Target/TargetOptions.h" 45da47e6e0d003c873da960361549e57ee4617c301Evan Cheng#include "llvm/Target/TargetRegisterInfo.h" 46cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng#include "llvm/ADT/SmallPtrSet.h" 47fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#include "llvm/ADT/SmallString.h" 486609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner#include <cerrno> 49a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerusing namespace llvm; 50a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 5142bf74be1402df7409efbea089310d4c276fde37Evan Chengstatic cl::opt<cl::boolOrDefault> 5242bf74be1402df7409efbea089310d4c276fde37Evan ChengAsmVerbose("asm-verbose", cl::desc("Add comments to directives."), 5342bf74be1402df7409efbea089310d4c276fde37Evan Cheng cl::init(cl::BOU_UNSET)); 5442bf74be1402df7409efbea089310d4c276fde37Evan Cheng 5507404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattnerstatic bool getVerboseAsm(bool VDef) { 5607404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner switch (AsmVerbose) { 5707404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner default: 5807404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner case cl::BOU_UNSET: return VDef; 5907404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner case cl::BOU_TRUE: return true; 6007404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner case cl::BOU_FALSE: return false; 6107404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner } 6207404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner} 6307404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner 641997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patelchar AsmPrinter::ID = 0; 6571847813bc419f7a0667468136a07429c6d9f164David GreeneAsmPrinter::AsmPrinter(formatted_raw_ostream &o, TargetMachine &tm, 66af76e592c7f9deff0e55c13dbb4a34f07f1c7f64Chris Lattner const MCAsmInfo *T, bool VDef) 675bcc8bd0c60cfe583ee47852950aad9e532c932eDaniel Dunbar : MachineFunctionPass(&ID), FunctionNumber(0), O(o), 6833adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner TM(tm), MAI(T), TRI(tm.getRegisterInfo()), 692b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 702b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner OutContext(*new MCContext()), 7190edac0e8b35f766599362b6301863229f0ddcdbChris Lattner // FIXME: Pass instprinter to streamer. 721658202529cf371e7e5f1a46d9ef80def5b3c3e0Chris Lattner OutStreamer(*createAsmStreamer(OutContext, O, *T, 7307404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner TM.getTargetData()->isLittleEndian(), 7407404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner getVerboseAsm(VDef), 0)), 752b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 766b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel LastMI(0), LastFn(0), Counter(~0U), PrevDLT(NULL) { 770de1fc4f416b3e94749ca84cdaede55b040a8b60Chris Lattner DW = 0; MMI = 0; 7807404415ab97883b80d0dd87f1c5308e4eccbfd4Chris Lattner VerboseAsm = getVerboseAsm(VDef); 7942bf74be1402df7409efbea089310d4c276fde37Evan Cheng} 80ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 81c317a60c2714a5b90700a11ba646285cb754a5d3Gordon HenriksenAsmPrinter::~AsmPrinter() { 82c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen for (gcp_iterator I = GCMetadataPrinters.begin(), 83c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen E = GCMetadataPrinters.end(); I != E; ++I) 84c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen delete I->second; 852b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 862b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner delete &OutStreamer; 872b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner delete &OutContext; 88c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen} 89ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 9038c398808cff7defdf013fa750dfac8e66302975Chris LattnerTargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { 91f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner return TM.getTargetLowering()->getObjFileLowering(); 92f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner} 93f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner 94dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner/// getCurrentSection() - Return the current section we are emitting to. 95dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattnerconst MCSection *AsmPrinter::getCurrentSection() const { 96dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner return OutStreamer.getCurrentSection(); 97b5a32e2e8ce2f3de3a340c5a2dfcd3a159968466Anton Korobeynikov} 984632d7a57008564c4b0f8246e85bd813a200d2c6Chris Lattner 99dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner 100ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksenvoid AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { 101845012e6d31799c7fbd1193fa1af8ee2d12e9231Dan Gohman AU.setPreservesAll(); 102ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen MachineFunctionPass::getAnalysisUsage(AU); 1035eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen AU.addRequired<GCModuleInfo>(); 104fe37ab335be5632eab561d49984c95cb06b946d4David Greene if (VerboseAsm) 105b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene AU.addRequired<MachineLoopInfo>(); 106ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen} 107ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 108a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerbool AsmPrinter::doInitialization(Module &M) { 109f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner // Initialize TargetLoweringObjectFile. 110f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner const_cast<TargetLoweringObjectFile&>(getObjFileLowering()) 111f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner .Initialize(OutContext, TM); 112f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner 113c0dba723d119adc8c7b49c6d0e97d10eac4428fcChris Lattner Mang = new Mangler(*MAI); 1142c1b1597f244c836771b4f2668c0ae399d32a5e9Chris Lattner 115812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson // Allow the target to emit any magic that it wants at the start of the file. 116812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson EmitStartOfAsmFile(M); 117952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola 11833adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->hasSingleParameterDotFile()) { 1193924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner // Very minimal debug info. It is ignored if we emit actual 1203924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner // debug info. If we don't, this at least helps the user find where 1213924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner // a function came from. 122952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola O << "\t.file\t\"" << M.getModuleIdentifier() << "\"\n"; 123952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola } 124952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola 125812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 126812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 1275eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I) 1285eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) 12933adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MP->beginAssembly(O, *this, *MAI); 130ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 1313e2fa7a746270452316523f27b9055b007feba32Chris Lattner if (!M.getModuleInlineAsm().empty()) 13233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << " Start of file scope inline assembly\n" 1333e2fa7a746270452316523f27b9055b007feba32Chris Lattner << M.getModuleInlineAsm() 13433adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner << '\n' << MAI->getCommentString() 135563321a2582851c653d0863e8e0bba3d483734f9Jim Laskey << " End of file scope inline assembly\n"; 1362c1b1597f244c836771b4f2668c0ae399d32a5e9Chris Lattner 137b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner MMI = getAnalysisIfAvailable<MachineModuleInfo>(); 138b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner if (MMI) 139b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner MMI->AnalyzeModule(M); 140b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner DW = getAnalysisIfAvailable<DwarfWriter>(); 1419a501cf19dbf1f56f0782ddba4c1931565af9610Sanjiv Gupta if (DW) 142b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner DW->BeginModule(&M, MMI, O, this, MAI); 14314a55d952cf238fff42da53a75f39cf06dab184bDevang Patel 144a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner return false; 145a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 146a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 14748d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner/// EmitGlobalVariable - Emit the specified global variable to the .s file. 14848d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattnervoid AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { 14948d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner if (!GV->hasInitializer()) // External globals require no code. 15048d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner return; 15148d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 15248d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner // Check to see if this is a special global used by LLVM, if so, emit it. 15348d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner if (EmitSpecialLLVMGlobal(GV)) 15448d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner return; 15574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 15674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner MCSymbol *GVSym = GetGlobalValueSymbol(GV); 15774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner printVisibility(GVSym, GV->getVisibility()); 15874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 15974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (MAI->hasDotTypeDotSizeDirective()) { 16074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner O << "\t.type\t" << *GVSym; 16174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (MAI->getCommentString()[0] != '@') 16274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner O << ",@object\n"; 16374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner else 16474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner O << ",%object\n"; 16574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 16674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 16774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM); 16874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 16974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner const TargetData *TD = TM.getTargetData(); 17074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner unsigned Size = TD->getTypeAllocSize(GV->getType()->getElementType()); 17174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner unsigned AlignLog = TD->getPreferredAlignmentLog(GV); 17274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 1739744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner // Handle common and BSS local symbols (.lcomm). 1749744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner if (GVKind.isCommon() || GVKind.isBSSLocal()) { 17574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. 17674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 17774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (VerboseAsm) { 1780fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), GV, 1790fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner /*PrintType=*/false, GV->getParent()); 1800fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << '\n'; 18174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 182814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 183814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // Handle common symbols. 1849744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner if (GVKind.isCommon()) { 1859744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner // .comm _foo, 42, 4 1864ed5438f4882c9fe779b1a8ff546877889b222dfChris Lattner OutStreamer.EmitCommonSymbol(GVSym, Size, 1 << AlignLog); 187814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 188814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner } 189814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 190814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // Handle local BSS symbols. 191814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner if (MAI->hasMachoZeroFillDirective()) { 192814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner const MCSection *TheSection = 193814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 194814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .zerofill __DATA, __bss, _foo, 400, 5 195814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 196814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 197814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner } 198814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 1999eb158d5b4cd4f6fc80912e2dd77bdf13c3ca0e7Chris Lattner if (MAI->hasLCOMMDirective()) { 200814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .lcomm _foo, 42 2019eb158d5b4cd4f6fc80912e2dd77bdf13c3ca0e7Chris Lattner OutStreamer.EmitLocalCommonSymbol(GVSym, Size); 202814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 20374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 204814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 205814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .local _foo 206a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Local); 207814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .comm _foo, 42, 4 208814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner OutStreamer.EmitCommonSymbol(GVSym, Size, 1 << AlignLog); 20974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner return; 21074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 21148d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 21274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner const MCSection *TheSection = 21374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 21474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 21574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // Handle the zerofill directive on darwin, which is a special form of BSS 21674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // emission. 21774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (GVKind.isBSSExtern() && MAI->hasMachoZeroFillDirective()) { 21874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .globl _foo 219a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 22074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .zerofill __DATA, __common, _foo, 400, 5 22174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 22274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner return; 22374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 22474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 22574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner OutStreamer.SwitchSection(TheSection); 22674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 22774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // TODO: Factor into an 'emit linkage' thing that is shared with function 22874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // bodies. 22974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner switch (GV->getLinkage()) { 23074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::CommonLinkage: 23174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::LinkOnceAnyLinkage: 23274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::LinkOnceODRLinkage: 23374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::WeakAnyLinkage: 23474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::WeakODRLinkage: 23574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::LinkerPrivateLinkage: 2364c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner if (MAI->getWeakDefDirective() != 0) { 23774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .globl _foo 238a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 23974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .weak_definition _foo 240a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefinition); 24174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } else if (const char *LinkOnce = MAI->getLinkOnceDirective()) { 24274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .globl _foo 243a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 24474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .linkonce same_size 24574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner O << LinkOnce; 2464c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner } else { 2474c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner // .weak _foo 248a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); 2494c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner } 25074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner break; 25174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::DLLExportLinkage: 25274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::AppendingLinkage: 25374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // FIXME: appending linkage variables should go into a section of 25474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // their name or something. For now, just emit them as external. 25574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::ExternalLinkage: 25674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // If external or appending, declare as a global symbol. 25774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .globl _foo 258a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 25974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner break; 26074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::PrivateLinkage: 26174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner case GlobalValue::InternalLinkage: 26274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner break; 26374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner default: 26474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner llvm_unreachable("Unknown linkage type!"); 26574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 26674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 26774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner EmitAlignment(AlignLog, GV); 26874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (VerboseAsm) { 2690fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), GV, 2700fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner /*PrintType=*/false, GV->getParent()); 2710fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << '\n'; 27274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 2734c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner OutStreamer.EmitLabel(GVSym); 27474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 27574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner EmitGlobalConstant(GV->getInitializer()); 27674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 27774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (MAI->hasDotTypeDotSizeDirective()) 2781947f242d40227d36440a2702a0a612c8077d72eChris Lattner // .size foo, 42 27999328add833807f12a4950c7de29fb2a5df04703Chris Lattner OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext)); 2800fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner 2810fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddBlankLine(); 28248d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner} 28348d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 28448d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 285a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerbool AsmPrinter::doFinalization(Module &M) { 28640bbebde9d250b875a47a688d0c6552834ada48fChris Lattner // Emit global variables. 28740bbebde9d250b875a47a688d0c6552834ada48fChris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 28840bbebde9d250b875a47a688d0c6552834ada48fChris Lattner I != E; ++I) 28948d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner EmitGlobalVariable(I); 29040bbebde9d250b875a47a688d0c6552834ada48fChris Lattner 2911f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner // Emit final debug information. 29233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->doesSupportDebugInformation() || MAI->doesSupportExceptionHandling()) 2931f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner DW->EndModule(); 2941f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner 2950a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // If the target wants to know about weak references, print them all. 29633adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->getWeakRefDirective()) { 2970a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // FIXME: This is not lazy, it would be nice to only print weak references 2980a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // to stuff that is actually used. Note that doing so would require targets 2990a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // to notice uses in operands (due to constant exprs etc). This should 3000a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // happen with the MC stuff eventually. 3010a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner 3020a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // Print out module-level global variables here. 3030a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 3040a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner I != E; ++I) { 30508ce3b473d06e0f7806df3d44b7b36ac40c58803Chris Lattner if (!I->hasExternalWeakLinkage()) continue; 3063924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(I), 307a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_WeakReference); 3080a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner } 3090a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner 310c6fdced3dbfdf673cc9b01dfad4f08e316d8803dChris Lattner for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 31108ce3b473d06e0f7806df3d44b7b36ac40c58803Chris Lattner if (!I->hasExternalWeakLinkage()) continue; 3123924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(I), 313a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_WeakReference); 3140a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner } 31515404d060ba8b604c03b9223a0f2e2abcd0fddedRafael Espindola } 31615404d060ba8b604c03b9223a0f2e2abcd0fddedRafael Espindola 31733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->getSetDirective()) { 3183a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.AddBlankLine(); 3198b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 3200a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner I != E; ++I) { 3215c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner MCSymbol *Name = GetGlobalValueSymbol(I); 322325be7c608a37d87e4f3d731e11fa3dd34f529b5Anton Korobeynikov 323325be7c608a37d87e4f3d731e11fa3dd34f529b5Anton Korobeynikov const GlobalValue *GV = cast<GlobalValue>(I->getAliasedGlobal()); 3245c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner MCSymbol *Target = GetGlobalValueSymbol(GV); 3255c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner 32610b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner if (I->hasExternalLinkage() || !MAI->getWeakRefDirective()) 327a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(Name, MCSA_Global); 32810b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner else if (I->hasWeakLinkage()) 329a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(Name, MCSA_WeakReference); 33010b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner else 33110595490ccf25b4960936638fac7a673eaf82e68Chris Lattner assert(I->hasLocalLinkage() && "Invalid alias linkage"); 33222c9e65643e0c6b43be37a19e59491ef0081092cAnton Korobeynikov 333541af7f769c89de8a7f52d563cf317ad7a86c245Anton Korobeynikov printVisibility(Name, I->getVisibility()); 33422c9e65643e0c6b43be37a19e59491ef0081092cAnton Korobeynikov 33510b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner O << MAI->getSetDirective() << ' ' << *Name << ", " << *Target << '\n'; 3368b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 3378b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 3388b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 3391465d61bdd36cfd6021036a527895f0dd358e97dDuncan Sands GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 3405eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 3415eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) 3425eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*--I)) 34333adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MP->finishAssembly(O, *this, *MAI); 344ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 345a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman // If we don't have any trampolines, then we don't require stack memory 346a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman // to be executable. Some targets have a directive to declare this. 3470a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline"); 348a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty()) 349f9f93e4388962b678fd59b7af5212d4cc0d38be2Chris Lattner if (MCSection *S = MAI->getNonexecutableStackSection(OutContext)) 350f9f93e4388962b678fd59b7af5212d4cc0d38be2Chris Lattner OutStreamer.SwitchSection(S); 351bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner 352bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner // Allow the target to emit any magic that it wants at the end of the file, 353bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner // after everything else has gone out. 354bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner EmitEndOfAsmFile(M); 355bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner 356a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner delete Mang; Mang = 0; 3570de1fc4f416b3e94749ca84cdaede55b040a8b60Chris Lattner DW = 0; MMI = 0; 3582b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 3592b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner OutStreamer.Finish(); 360a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner return false; 361a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 362a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 36325045bdcda822d63674e2df7e34016536c5d3fa7Chris Lattnervoid AsmPrinter::SetupMachineFunction(MachineFunction &MF) { 364412c3a5bc9e70fe8579551216786e70d323a3dd5Chris Lattner // Get the function symbol. 365d1947ed2f824d2e9f4923fb6efc2aec4a6e3e96dChris Lattner CurrentFnSym = GetGlobalValueSymbol(MF.getFunction()); 366347d39f1fd8ad825a7ec5b8a3dce816723a56d42Evan Cheng IncrementFunctionNumber(); 367b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene 36825d812bd7d1f58f2ba1b598b1425a2e146e27381Chris Lattner if (VerboseAsm) 369b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene LI = &getAnalysis<MachineLoopInfo>(); 370a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 371a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 3721606e8e4cd937e6de6681f686c266cf61722d972Evan Chengnamespace { 3731606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // SectionCPs - Keep track the alignment, constpool entries per Section. 3741606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng struct SectionCPs { 375a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner const MCSection *S; 3761606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment; 3771606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SmallVector<unsigned, 4> CPEs; 378cabdd7425d30f7eb659ecb0cc5efbc4052dd78a8Douglas Gregor SectionCPs(const MCSection *s, unsigned a) : S(s), Alignment(a) {} 3791606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng }; 3801606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng} 3811606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 3823b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// EmitConstantPool - Print to the current output stream assembly 3833b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// representations of the constants in the constant pool MCP. This is 3843b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// used to print out constants which have been "spilled to memory" by 3853b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// the code generator. 3863b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// 3873b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattnervoid AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) { 388fa77d43ba1d91ed39f46e11caeb28dcabae9e193Chris Lattner const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); 3893b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner if (CP.empty()) return; 3902d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 391088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // Calculate sections for constant pool entries. We collect entries to go into 392088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // the same section together to reduce amount of section switch statements. 3931606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SmallVector<SectionCPs, 4> CPSections; 3942d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng for (unsigned i = 0, e = CP.size(); i != e; ++i) { 395298414ec1891ce8d3a1b69e6019ad8765c8e69dcChris Lattner const MachineConstantPoolEntry &CPE = CP[i]; 3961606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Align = CPE.getAlignment(); 3975c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner 3985c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner SectionKind Kind; 3995c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner switch (CPE.getRelocationInfo()) { 4005c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner default: llvm_unreachable("Unknown section kind"); 4012798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 2: Kind = SectionKind::getReadOnlyWithRel(); break; 4024c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner case 1: 4032798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner Kind = SectionKind::getReadOnlyWithRelLocal(); 4044c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner break; 4055c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner case 0: 4064c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { 4072798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 4: Kind = SectionKind::getMergeableConst4(); break; 4082798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 8: Kind = SectionKind::getMergeableConst8(); break; 4092798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 16: Kind = SectionKind::getMergeableConst16();break; 4102798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner default: Kind = SectionKind::getMergeableConst(); break; 4114c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner } 4125c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner } 4135c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner 41483d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner const MCSection *S = getObjFileLowering().getSectionForConstant(Kind); 415298414ec1891ce8d3a1b69e6019ad8765c8e69dcChris Lattner 4161606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // The number of sections are small, just do a linear search from the 4171606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // last section to the first. 4181606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng bool Found = false; 4191606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned SecIdx = CPSections.size(); 4201606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng while (SecIdx != 0) { 4211606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (CPSections[--SecIdx].S == S) { 4221606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Found = true; 4231606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng break; 4241606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4251606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4261606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (!Found) { 4271606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SecIdx = CPSections.size(); 4281606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections.push_back(SectionCPs(S, Align)); 4291606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4301606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 4311606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (Align > CPSections[SecIdx].Alignment) 4321606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections[SecIdx].Alignment = Align; 4331606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections[SecIdx].CPEs.push_back(i); 4342d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng } 4352d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 436088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // Now print stuff into the calculated sections. 4371606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng for (unsigned i = 0, e = CPSections.size(); i != e; ++i) { 4386c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(CPSections[i].S); 4391606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitAlignment(Log2_32(CPSections[i].Alignment)); 4402d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 4411606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Offset = 0; 4421606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) { 4431606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned CPI = CPSections[i].CPEs[j]; 4441606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng MachineConstantPoolEntry CPE = CP[CPI]; 4451606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 4461606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // Emit inter-object padding for alignment. 4471606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned AlignMask = CPE.getAlignment() - 1; 4481606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned NewOffset = (Offset + AlignMask) & ~AlignMask; 449aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner OutStreamer.EmitFill(NewOffset - Offset, 0/*fillval*/, 0/*addrspace*/); 4501606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 4511606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng const Type *Ty = CPE.getType(); 452777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands Offset = NewOffset + TM.getTargetData()->getTypeAllocSize(Ty); 4532d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 4543924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner // Emit the label with a comment on it. 4551606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (VerboseAsm) { 4563924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.GetCommentOS() << "constant pool "; 4573924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner WriteTypeSymbolic(OutStreamer.GetCommentOS(), CPE.getType(), 4583924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner MF->getFunction()->getParent()); 4593924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.GetCommentOS() << '\n'; 4601606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4613924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitLabel(GetCPISymbol(CPI)); 4623924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 4631606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (CPE.isMachineConstantPoolEntry()) 4641606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitMachineConstantPoolValue(CPE.Val.MachineCPVal); 465088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov else 4661606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitGlobalConstant(CPE.Val.ConstVal); 4673029f920519e0871a5aad5d7c592281093953733Chris Lattner } 4683b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner } 4693b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner} 4703b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner 47137efe6764568a3829fee26aba532283131d1a104Nate Begeman/// EmitJumpTableInfo - Print assembly representations of the jump tables used 47237efe6764568a3829fee26aba532283131d1a104Nate Begeman/// by the current function to the current output stream. 47337efe6764568a3829fee26aba532283131d1a104Nate Begeman/// 4741da31ee472b9615d7329c656e2cc17c419ed7c95Chris Lattnervoid AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI, 4751da31ee472b9615d7329c656e2cc17c419ed7c95Chris Lattner MachineFunction &MF) { 47637efe6764568a3829fee26aba532283131d1a104Nate Begeman const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 47737efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.empty()) return; 4789de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 479acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey bool IsPic = TM.getRelocationModel() == Reloc::PIC_; 4804d9bbdc4408cc871d229677313cc4887862719d7Nate Begeman 4812f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman // Pick the directive to use to print the jump table entries, and switch to 4822f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman // the appropriate section. 483acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey TargetLowering *LoweringInfo = TM.getTargetLowering(); 48424287ddb81aca5d2579dc30ebd3528d2521529d7Anton Korobeynikov 485e87f52d722d4184becb2ecaf4500dd01d176bfc2Anton Korobeynikov const Function *F = MF.getFunction(); 486b13bafe5c12dd908b55c559c93adaeb1627ed096Evan Cheng bool JTInDiffSection = false; 48783d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner if (F->isWeakForLinker() || 48883d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner (IsPic && !LoweringInfo->usesGlobalOffsetTable())) { 489acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey // In PIC mode, we need to emit the jump table to the same section as the 490acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey // function body itself, otherwise the label differences won't make sense. 491e87f52d722d4184becb2ecaf4500dd01d176bfc2Anton Korobeynikov // We should also do if the section name is NULL or function is declared in 492e87f52d722d4184becb2ecaf4500dd01d176bfc2Anton Korobeynikov // discardable section. 4936c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, 4946c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner TM)); 4952f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } else { 49683d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner // Otherwise, drop it in the readonly section. 49783d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner const MCSection *ReadOnlySection = 4982798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly()); 4996c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(ReadOnlySection); 500b13bafe5c12dd908b55c559c93adaeb1627ed096Evan Cheng JTInDiffSection = true; 5012f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } 502acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey 503acd80ac7bb19f8bdfa55336d567c9ecbe695c8b8Jim Laskey EmitAlignment(Log2_32(MJTI->getAlignment())); 5040c4e6789da4dba6c7b0010886776b24dec3f3bb8Chris Lattner 50537efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned i = 0, e = JT.size(); i != e; ++i) { 50652a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman const std::vector<MachineBasicBlock*> &JTBBs = JT[i].MBBs; 50707371882208f913d18a7f2a47373eaee7138416bChris Lattner 50807371882208f913d18a7f2a47373eaee7138416bChris Lattner // If this jump table was deleted, ignore it. 50907371882208f913d18a7f2a47373eaee7138416bChris Lattner if (JTBBs.empty()) continue; 51052a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 51152a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman // For PIC codegen, if possible we want to use the SetDirective to reduce 51252a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman // the number of relocations the assembler will generate for the jump table. 51352a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman // Set directives are all printed before the jump table itself. 514cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng SmallPtrSet<MachineBasicBlock*, 16> EmittedSets; 51533adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->getSetDirective() && IsPic) 51652a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) 517cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng if (EmittedSets.insert(JTBBs[ii])) 518cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng printPICJumpTableSetLabel(i, JTBBs[ii]); 51952a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 5207c30191393c99c9ba804f1a01942a9e130c53904Chris Lattner // On some targets (e.g. Darwin) we want to emit two consequtive labels 521393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // before each jump table. The first label is never referenced, but tells 522393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // the assembler and linker the extents of the jump table object. The 523393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // second label is actually referenced by the code. 5243924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner if (JTInDiffSection && MAI->getLinkerPrivateGlobalPrefix()[0]) 5253924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitLabel(GetJTISymbol(i, true)); 5263924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 5273924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitLabel(GetJTISymbol(i)); 5283924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 52937efe6764568a3829fee26aba532283131d1a104Nate Begeman for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { 5309de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov printPICJumpTableEntry(MJTI, JTBBs[ii], i); 53137efe6764568a3829fee26aba532283131d1a104Nate Begeman O << '\n'; 53237efe6764568a3829fee26aba532283131d1a104Nate Begeman } 53337efe6764568a3829fee26aba532283131d1a104Nate Begeman } 53437efe6764568a3829fee26aba532283131d1a104Nate Begeman} 53537efe6764568a3829fee26aba532283131d1a104Nate Begeman 5369de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikovvoid AsmPrinter::printPICJumpTableEntry(const MachineJumpTableInfo *MJTI, 5379de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov const MachineBasicBlock *MBB, 5389de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov unsigned uid) const { 539b3ac6e40d9dd3bc8157edc47004f39c8f382dc9eChris Lattner bool isPIC = TM.getRelocationModel() == Reloc::PIC_; 5409de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 5419de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // Use JumpTableDirective otherwise honor the entry size from the jump table 5429de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // info. 54333adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner const char *JTEntryDirective = MAI->getJumpTableDirective(isPIC); 5449de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov bool HadJTEntryDirective = JTEntryDirective != NULL; 5459de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov if (!HadJTEntryDirective) { 5469de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov JTEntryDirective = MJTI->getEntrySize() == 4 ? 54733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MAI->getData32bitsDirective() : MAI->getData64bitsDirective(); 5489de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } 5499de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 5509de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov O << JTEntryDirective << ' '; 5519de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 5529de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // If we have emitted set directives for the jump table entries, print 5539de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // them rather than the entries themselves. If we're emitting PIC, then 5549de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // emit the table entries as differences between two text section labels. 5559de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // If we're emitting non-PIC code, then emit the entries as direct 5569de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov // references to the target basic blocks. 557b3ac6e40d9dd3bc8157edc47004f39c8f382dc9eChris Lattner if (!isPIC) { 55810b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner O << *GetMBBSymbol(MBB->getNumber()); 55933adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner } else if (MAI->getSetDirective()) { 56033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getPrivateGlobalPrefix() << getFunctionNumber() 561b3ac6e40d9dd3bc8157edc47004f39c8f382dc9eChris Lattner << '_' << uid << "_set_" << MBB->getNumber(); 5629de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } else { 56310b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner O << *GetMBBSymbol(MBB->getNumber()); 564b3ac6e40d9dd3bc8157edc47004f39c8f382dc9eChris Lattner // If the arch uses custom Jump Table directives, don't calc relative to 5653a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner // JT. 566b3ac6e40d9dd3bc8157edc47004f39c8f382dc9eChris Lattner if (!HadJTEntryDirective) 5673924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner O << '-' << *GetJTISymbol(uid); 5689de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } 5699de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov} 5709de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 5719de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 572ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// EmitSpecialLLVMGlobal - Check to see if the specified global is a 573ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// special global used by LLVM. If so, emit it and return true, otherwise 574ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// do nothing and return false. 575ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattnerbool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { 57603d7651c3652e1f0cc86e79b26585d86818da9cfDaniel Dunbar if (GV->getName() == "llvm.used") { 5773a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner if (MAI->hasNoDeadStrip()) // No need to emit this at all. 578b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth EmitLLVMUsedList(GV->getInitializer()); 579b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth return true; 580b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth } 581b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth 582401e10c4fbfcdcfade5065093e2ca97f69a1d144Chris Lattner // Ignore debug and non-emitted data. This handles llvm.compiler.used. 583266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner if (GV->getSection() == "llvm.metadata" || 584266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner GV->hasAvailableExternallyLinkage()) 585266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner return true; 5867809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey 5877809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey if (!GV->hasAppendingLinkage()) return false; 5887809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey 5897809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey assert(GV->hasInitializer() && "Not a special LLVM global!"); 590ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 591916d07cdfa89e77118043ec6e14575512ae1bf85Evan Cheng const TargetData *TD = TM.getTargetData(); 592916d07cdfa89e77118043ec6e14575512ae1bf85Evan Cheng unsigned Align = Log2_32(TD->getPointerPrefAlignment()); 593f231c07228deb75b6cd5ae7c9c057bc8303c6998Chris Lattner if (GV->getName() == "llvm.global_ctors") { 5946c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().getStaticCtorSection()); 595ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitAlignment(Align, 0); 596ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitXXStructorList(GV->getInitializer()); 59771eae713153e564ec743c5c4162ff258c255de78Chris Lattner 59871eae713153e564ec743c5c4162ff258c255de78Chris Lattner if (TM.getRelocationModel() == Reloc::Static && 5993a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner MAI->hasStaticCtorDtorReferenceInStaticMode()) { 6003a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner StringRef Sym(".constructors_used"); 6013a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 602a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_Reference); 6033a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner } 604ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner return true; 605ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 606ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 607f231c07228deb75b6cd5ae7c9c057bc8303c6998Chris Lattner if (GV->getName() == "llvm.global_dtors") { 6086c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().getStaticDtorSection()); 609ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitAlignment(Align, 0); 610ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitXXStructorList(GV->getInitializer()); 61171eae713153e564ec743c5c4162ff258c255de78Chris Lattner 61271eae713153e564ec743c5c4162ff258c255de78Chris Lattner if (TM.getRelocationModel() == Reloc::Static && 6133a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner MAI->hasStaticCtorDtorReferenceInStaticMode()) { 6143a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner StringRef Sym(".destructors_used"); 6153a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 616a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_Reference); 6173a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner } 618ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner return true; 619ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 620ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 621ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner return false; 622ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner} 623ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 62433adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each 625d2e51af0358b571367a9f1e5175b87e9dd72edf8Dale Johannesen/// global in the specified llvm.used list for which emitUsedDirectiveFor 626d2e51af0358b571367a9f1e5175b87e9dd72edf8Dale Johannesen/// is true, as being used with this directive. 627cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattnervoid AsmPrinter::EmitLLVMUsedList(Constant *List) { 628a119de86a064414622562cfe32953de7f9b0ee40Dan Gohman // Should be an array of 'i8*'. 629cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner ConstantArray *InitList = dyn_cast<ConstantArray>(List); 630cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner if (InitList == 0) return; 631cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner 632cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 63316fe990e56102a355f1e77aca93bf8c79d7b9eb2Chris Lattner const GlobalValue *GV = 63416fe990e56102a355f1e77aca93bf8c79d7b9eb2Chris Lattner dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts()); 6353a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner if (GV && getObjFileLowering().shouldEmitUsedDirectiveFor(GV, Mang)) 6363a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(GV), 637a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_NoDeadStrip); 638cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner } 639cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner} 640cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner 641ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the 642ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// function pointers, ignoring the init priority. 643ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattnervoid AsmPrinter::EmitXXStructorList(Constant *List) { 644ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner // Should be an array of '{ int, void ()* }' structs. The first value is the 645ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner // init priority, which we ignore. 646ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (!isa<ConstantArray>(List)) return; 647ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner ConstantArray *InitList = cast<ConstantArray>(List); 648ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 649ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ 650ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. 6518de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner 6528de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner if (CS->getOperand(1)->isNullValue()) 6538de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner return; // Found a null terminator, exit printing. 6548de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner // Emit the function pointer. 655ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner EmitGlobalConstant(CS->getOperand(1)); 656ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 657ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner} 6583b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner 659f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey//===--------------------------------------------------------------------===// 660f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey// Emission and print routines 661f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey// 662f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 663f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt8 - Emit a byte directive and value. 664f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 665f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt8(int Value) const { 6665eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 1, 0/*addrspace*/); 667f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 668f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 669f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt16 - Emit a short directive and value. 670f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 671f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt16(int Value) const { 6725eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 2, 0/*addrspace*/); 673f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 674f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 675f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt32 - Emit a long directive and value. 676f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 677f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt32(int Value) const { 6785eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 4, 0/*addrspace*/); 679f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 680f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 681f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt64 - Emit a long long directive and value. 682f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 683f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt64(uint64_t Value) const { 6845eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 8, 0/*addrspace*/); 685f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 686f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 68705f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 688f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// toOctal - Convert the low order bits of X into an octal digit. 689f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 690f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeystatic inline char toOctal(int X) { 691f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey return (X&7)+'0'; 692f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 693f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 694f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// printStringChar - Print a char, escaped if necessary. 695f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 69671847813bc419f7a0667468136a07429c6d9f164David Greenestatic void printStringChar(formatted_raw_ostream &O, unsigned char C) { 697f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey if (C == '"') { 698f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << "\\\""; 699f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey } else if (C == '\\') { 700f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << "\\\\"; 701bbfa244b2fa986c53a1bcf38b6dd0fea082afaaaChris Lattner } else if (isprint((unsigned char)C)) { 702f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << C; 703f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey } else { 704f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey switch(C) { 705f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey case '\b': O << "\\b"; break; 706f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey case '\f': O << "\\f"; break; 707f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey case '\n': O << "\\n"; break; 708f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey case '\r': O << "\\r"; break; 709f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey case '\t': O << "\\t"; break; 710f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey default: 711f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << '\\'; 712f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << toOctal(C >> 6); 713f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << toOctal(C >> 3); 714f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey O << toOctal(C >> 0); 715f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey break; 716f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey } 717f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey } 718f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 719f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 720189f80dc253664627253b2d2cb07d0714feb12baDan Gohman/// EmitFile - Emit a .file directive. 7211efd4fd56b3bc21b85ab921c6f77807afc02ecb5Benjamin Kramervoid AsmPrinter::EmitFile(unsigned Number, StringRef Name) const { 722189f80dc253664627253b2d2cb07d0714feb12baDan Gohman O << "\t.file\t" << Number << " \""; 723a118c2ee89842346ef2fd332c0fea6b931d79483Chris Lattner for (unsigned i = 0, N = Name.size(); i < N; ++i) 724a118c2ee89842346ef2fd332c0fea6b931d79483Chris Lattner printStringChar(O, Name[i]); 725d19a53ba1d4629f69821f37ca824c65e6df8e8f9Dan Gohman O << '\"'; 726189f80dc253664627253b2d2cb07d0714feb12baDan Gohman} 727189f80dc253664627253b2d2cb07d0714feb12baDan Gohman 728189f80dc253664627253b2d2cb07d0714feb12baDan Gohman 729f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey//===----------------------------------------------------------------------===// 730f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 7313a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// EmitAlignment - Emit an alignment directive to the specified power of 7323a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// two boundary. For example, if you pass in 3 here, you will get an 8 7333a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// byte alignment. If a global value is specified, and if that global has 7343a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// an explicit alignment requested, it will unconditionally override the 7353a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// alignment request. However, if ForcedAlignBits is specified, this value 7363a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// has final say: the ultimate alignment will be the max of ForcedAlignBits 7373a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// and the alignment computed with NumBits and the global. 7383a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// 7393a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// The algorithm is: 7403a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// Align = NumBits; 7413a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// if (GV && GV->hasalignment) Align = GV->getalignment(); 7423a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// Align = std::max(Align, ForcedAlignBits); 7433a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// 7443a4205367dc845d4cd804b47e061f8281777c9daChris Lattnervoid AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV, 74505548eb174dd694b651de334b73197a62e5071f1Evan Cheng unsigned ForcedAlignBits, 74605548eb174dd694b651de334b73197a62e5071f1Evan Cheng bool UseFillExpr) const { 74700d56b96e599acbc4f895e86e17029ae7c45f142Dale Johannesen if (GV && GV->getAlignment()) 7483a4205367dc845d4cd804b47e061f8281777c9daChris Lattner NumBits = Log2_32(GV->getAlignment()); 7493a4205367dc845d4cd804b47e061f8281777c9daChris Lattner NumBits = std::max(NumBits, ForcedAlignBits); 7503a4205367dc845d4cd804b47e061f8281777c9daChris Lattner 7512a21c6e86101c857d683e7bdefb775654ccab7e3Chris Lattner if (NumBits == 0) return; // No need to emit alignment. 752663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner 753663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner unsigned FillValue = 0; 754dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner if (getCurrentSection()->getKind().isText()) 75533adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner FillValue = MAI->getTextAlignFillValue(); 756663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner 757663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner OutStreamer.EmitValueToAlignment(1 << NumBits, FillValue, 1, 0); 758bfddc2030a7e67b9e0c42276525d6932375ff261Chris Lattner} 759a5bb59f85613e8ce481351803e7388f5ab466e72David Greene 76052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner/// LowerConstant - Lower the specified LLVM Constant to an MCExpr. 76152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner/// 76252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattnerstatic const MCExpr *LowerConstant(const Constant *CV, AsmPrinter &AP) { 76352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner MCContext &Ctx = AP.OutContext; 764fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 76552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (CV->isNullValue() || isa<UndefValue>(CV)) 76652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(0, Ctx); 76752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 76852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) 76952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(CI->getZExtValue(), Ctx); 770fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 77152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) 77252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCSymbolRefExpr::Create(AP.GetGlobalValueSymbol(GV), Ctx); 77352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) 77452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx); 775fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 776fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV); 777fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner if (CE == 0) { 77852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner llvm_unreachable("Unknown constant value to lower!"); 77952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(0, Ctx); 780fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 781fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 782fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner switch (CE->getOpcode()) { 783fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::ZExt: 784fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::SExt: 785fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPTrunc: 786fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPExt: 787fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::UIToFP: 788fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::SIToFP: 789fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPToUI: 790fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPToSI: 79152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner default: llvm_unreachable("FIXME: Don't support this constant cast expr"); 792fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::GetElementPtr: { 79352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 79452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Generate a symbolic expression for the byte address 79552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const Constant *PtrVal = CE->getOperand(0); 79652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner SmallVector<Value*, 8> IdxVec(CE->op_begin()+1, CE->op_end()); 79752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner int64_t Offset = TD.getIndexedOffset(PtrVal->getType(), &IdxVec[0], 79852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner IdxVec.size()); 79952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 80052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *Base = LowerConstant(CE->getOperand(0), AP); 801fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner if (Offset == 0) 80252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return Base; 803fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 804fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Truncate/sext the offset to the pointer size. 80552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (TD.getPointerSizeInBits() != 64) { 80652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner int SExtAmount = 64-TD.getPointerSizeInBits(); 807fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Offset = (Offset << SExtAmount) >> SExtAmount; 808a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 809fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 81052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx), 81152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner Ctx); 812fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 81352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 81452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Trunc: 81552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // We emit the value and depend on the assembler to truncate the generated 81652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // expression properly. This is important for differences between 81752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // blockaddress labels. Since the two labels are in the same function, it 81852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // is reasonable to treat their delta as a 32-bit value. 81952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // FALL THROUGH. 820fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::BitCast: 82152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return LowerConstant(CE->getOperand(0), AP); 822fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 823fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::IntToPtr: { 82452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 825fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Handle casts to pointers by changing them into casts to the appropriate 826fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // integer type. This promotes constant folding and simplifies this code. 827fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Constant *Op = CE->getOperand(0); 82852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()), 829fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner false/*ZExt*/); 83052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return LowerConstant(Op, AP); 831fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 832fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 833fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::PtrToInt: { 83452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 835fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Support only foldable casts to/from pointers that can be eliminated by 836fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // changing the pointer to the appropriately sized integer type. 837fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Constant *Op = CE->getOperand(0); 838fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner const Type *Ty = CE->getType(); 83952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 84052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *OpExpr = LowerConstant(Op, AP); 841fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 842fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // We can emit the pointer value into this slot if the slot is an 84352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // integer slot equal to the size of the pointer. 84452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType())) 84552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return OpExpr; 84652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 84752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Otherwise the pointer is smaller than the resultant integer, mask off 84852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // the high bits so we are sure to get a proper truncation if the input is 84952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // a constant expr. 85052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType()); 85152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx); 85252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx); 853fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 854ddc94019916fbe4d3fff915e6002c39c63488a44Chris Lattner 855fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Add: 856fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Sub: 857fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::And: 858fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Or: 85952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Xor: { 86052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *LHS = LowerConstant(CE->getOperand(0), AP); 86152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *RHS = LowerConstant(CE->getOperand(1), AP); 862fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner switch (CE->getOpcode()) { 86352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner default: llvm_unreachable("Unknown binary operator constant cast expr"); 86452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx); 86552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx); 86652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx); 86752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Or: return MCBinaryExpr::CreateOr (LHS, RHS, Ctx); 86852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx); 869a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 87052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner } 871a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 872a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 8731b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner 87491093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantArray(const ConstantArray *CA, unsigned AddrSpace, 87591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AsmPrinter &AP) { 87605f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner if (AddrSpace != 0 || !CA->isString()) { 87705f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner // Not a string. Print the values in successive locations 87891093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 87991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AP.EmitGlobalConstant(CA->getOperand(i), AddrSpace); 88005f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner return; 88100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 88205f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 88305f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner // Otherwise, it can be emitted as .ascii. 88405f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner SmallVector<char, 128> TmpVec; 88505f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner TmpVec.reserve(CA->getNumOperands()); 88605f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 88705f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner TmpVec.push_back(cast<ConstantInt>(CA->getOperand(i))->getZExtValue()); 88805f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 88905f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner AP.OutStreamer.EmitBytes(StringRef(TmpVec.data(), TmpVec.size()), AddrSpace); 89000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 89100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 89291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantVector(const ConstantVector *CV, 89391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 894bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) 89591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AP.EmitGlobalConstant(CV->getOperand(i), AddrSpace); 89600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 89700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 89891093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantStruct(const ConstantStruct *CS, 89991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 90000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Print the fields in successive locations. Pad to align if needed! 90191093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner const TargetData *TD = AP.TM.getTargetData(); 90291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned Size = TD->getTypeAllocSize(CS->getType()); 9032dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const StructLayout *Layout = TD->getStructLayout(CS->getType()); 90491093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner uint64_t SizeSoFar = 0; 90591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) { 906bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner const Constant *Field = CS->getOperand(i); 90700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 90800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Check if padding is needed and insert one or more 0s. 909bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner uint64_t FieldSize = TD->getTypeAllocSize(Field->getType()); 9102dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1)) 9112dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner - Layout->getElementOffset(i)) - FieldSize; 9122dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner SizeSoFar += FieldSize + PadSize; 91300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 91400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Now print the actual field value. 915bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner AP.EmitGlobalConstant(Field, AddrSpace); 91600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 91700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Insert padding - this may include padding to increase the size of the 91800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // current field up to the ABI size (if the struct is not packed) as well 91900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // as padding to ensure that the next field starts at the right offset. 9202dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitZeros(PadSize, AddrSpace); 92100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 9222dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner assert(SizeSoFar == Layout->getSizeInBytes() && 92300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman "Layout of constant struct may be incorrect!"); 92400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 92500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 9262dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattnerstatic void EmitGlobalConstantFP(const ConstantFP *CFP, unsigned AddrSpace, 9272dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AsmPrinter &AP) { 92800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // FP Constants are printed as integer constants to avoid losing 9299ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner // precision. 930cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isDoubleTy()) { 9312dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 932d79d9dce47d505369662ae5111dba24f9ccdef68Chris Lattner double Val = CFP->getValueAPF().convertToDouble(); 933d79d9dce47d505369662ae5111dba24f9ccdef68Chris Lattner AP.OutStreamer.GetCommentOS() << "double " << Val << '\n'; 93409ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner } 93509ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner 9362dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 9372dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 93800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 939cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 940cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 941cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isFloatTy()) { 9422dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 9430fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner float Val = CFP->getValueAPF().convertToFloat(); 9440fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner AP.OutStreamer.GetCommentOS() << "float " << Val << '\n'; 945a12e9d751b64767a5c41a718da2a91122d5874c4Dan Gohman } 9462dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 9472dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 4, AddrSpace); 94800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 949cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 950cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 951cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isX86_FP80Ty()) { 95200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // all long double variants are printed as hex 95300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // api needed to prevent premature destruction 95409ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner APInt API = CFP->getValueAPF().bitcastToAPInt(); 95509ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner const uint64_t *p = API.getRawData(); 9562dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 95772b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner // Convert to double so we can print the approximate val as a comment. 95872b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner APFloat DoubleVal = CFP->getValueAPF(); 95972b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner bool ignored; 96072b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 96172b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner &ignored); 9620fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner AP.OutStreamer.GetCommentOS() << "x86_fp80 ~= " 9630fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner << DoubleVal.convertToDouble() << '\n'; 96472b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner } 96572b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner 9662dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.TM.getTargetData()->isBigEndian()) { 9672dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 9682dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 96972b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner } else { 9702dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 9712dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 97200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 9739ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner 9749ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner // Emit the tail padding for the long double. 9752dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 9762dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitZeros(TD.getTypeAllocSize(CFP->getType()) - 9772dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner TD.getTypeStoreSize(CFP->getType()), AddrSpace); 97800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 979cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 980cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 98109ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner assert(CFP->getType()->isPPC_FP128Ty() && 98209ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner "Floating point constant type not handled"); 98309ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner // All long double variants are printed as hex api needed to prevent 98409ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner // premature destruction. 98509ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner APInt API = CFP->getValueAPF().bitcastToAPInt(); 98609ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner const uint64_t *p = API.getRawData(); 9872dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.TM.getTargetData()->isBigEndian()) { 9882dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 9892dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 9909ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner } else { 9912dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 9922dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 99309ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner } 99400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 99500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 9962dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattnerstatic void EmitGlobalConstantLargeInt(const ConstantInt *CI, 9972dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 9982dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const TargetData *TD = AP.TM.getTargetData(); 99900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman unsigned BitWidth = CI->getBitWidth(); 100038c2b0a99c6a3f5cdf6ef5a46e4a6826b30acbfbChris Lattner assert((BitWidth & 63) == 0 && "only support multiples of 64-bits"); 100100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 100200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // We don't expect assemblers to support integer data directives 100300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // for more than 64 bits, so we emit the data in at most 64-bit 100400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // quantities at a time. 100500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman const uint64_t *RawData = CI->getValue().getRawData(); 100600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { 10072dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = TD->isBigEndian() ? RawData[e - i - 1] : RawData[i]; 10082dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 100900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 101000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 101100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 101225045bdcda822d63674e2df7e34016536c5d3fa7Chris Lattner/// EmitGlobalConstant - Print a general LLVM constant to the .s file. 1013c8d7bc850ddf5a5df503a173b0bc0f8c03ffec96Sanjiv Guptavoid AsmPrinter::EmitGlobalConstant(const Constant *CV, unsigned AddrSpace) { 1014043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV)) { 10152dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 10166449abfbc86310edbbe0b5ffb3fad5c14301307fChris Lattner return OutStreamer.EmitZeros(Size, AddrSpace); 10172dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 10182dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner 10192dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 10202dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner unsigned Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 10212dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner switch (Size) { 10222dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 1: 10232dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 2: 10242dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 4: 10252dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 8: 10260fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) 10270fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << format("0x%llx\n", CI->getZExtValue()); 10282dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner OutStreamer.EmitIntValue(CI->getZExtValue(), Size, AddrSpace); 10292dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return; 10302dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner default: 10312dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner EmitGlobalConstantLargeInt(CI, AddrSpace, *this); 10322dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return; 10332dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 10342dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 10353cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 103691093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) 103791093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantArray(CVA, AddrSpace, *this); 10383cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 103991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) 104091093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantStruct(CVS, AddrSpace, *this); 10413cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 104291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) 10432dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return EmitGlobalConstantFP(CFP, AddrSpace, *this); 10443cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 104591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantVector *V = dyn_cast<ConstantVector>(CV)) 104691093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantVector(V, AddrSpace, *this); 10471b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner 1048b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner if (isa<ConstantPointerNull>(CV)) { 1049b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner unsigned Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 1050b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner OutStreamer.EmitIntValue(0, Size, AddrSpace); 1051b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner return; 1052b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner } 1053b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner 105452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it 105552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // thread the streamer with EmitValue. 105652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner OutStreamer.EmitValue(LowerConstant(CV, *this), 105752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner TM.getTargetData()->getTypeAllocSize(CV->getType()), 105852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner AddrSpace); 10591b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner} 10600264d1a4777370009176157b76d116b3195e3767Chris Lattner 1061fad86b003a839cef40ec8ce8408322f4913368caChris Lattnervoid AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { 1062d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // Target doesn't support this yet! 1063c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Target does not support EmitMachineConstantPoolValue"); 1064d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 1065d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 10663ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// PrintSpecial - Print information related to the specified machine instr 10673ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// that is independent of the operand, and may be independent of the instr 10683ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// itself. This can be useful for portably encoding the comment character 10693ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// or other bits of target-specific knowledge into the asmstrings. The 10703ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// syntax used is ${:comment}. Targets can override this to add support 10713ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// for their own strange codes. 10723e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattnervoid AsmPrinter::PrintSpecial(const MachineInstr *MI, const char *Code) const { 1073bae02cfd46c569bb571a234544fb1bbe19c43b59Chris Lattner if (!strcmp(Code, "private")) { 107433adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getPrivateGlobalPrefix(); 1075bae02cfd46c569bb571a234544fb1bbe19c43b59Chris Lattner } else if (!strcmp(Code, "comment")) { 1076f1c0ae9de5365a578fbdfebe4625fb281b0be592Evan Cheng if (VerboseAsm) 107733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString(); 10783ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } else if (!strcmp(Code, "uid")) { 1079b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner // Comparing the address of MI isn't sufficient, because machineinstrs may 1080b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner // be allocated to the same address across functions. 1081b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner const Function *ThisF = MI->getParent()->getParent()->getFunction(); 1082b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner 1083bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson // If this is a new LastFn instruction, bump the counter. 1084bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson if (LastMI != MI || LastFn != ThisF) { 1085b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner ++Counter; 1086b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner LastMI = MI; 1087bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson LastFn = ThisF; 1088b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner } 10893ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner O << Counter; 10903ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } else { 10917d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin std::string msg; 10927d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin raw_string_ostream Msg(msg); 10937d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin Msg << "Unknown special formatter '" << Code 1094e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "' for machine instr: " << *MI; 10957d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error(Msg.str()); 10963ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } 10973ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner} 10983ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner 1099cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis/// processDebugLoc - Processes the debug information of each machine 1100cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis/// instruction's DebugLoc. 1101af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patelvoid AsmPrinter::processDebugLoc(const MachineInstr *MI, 1102af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patel bool BeforePrintingInsn) { 110353bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (!MAI || !DW || !MAI->doesSupportDebugInformation() 110453bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel || !DW->ShouldEmitDwarfDebug()) 1105d250329291dd9fe0d5f0e72e6cf1e287558a7cbaChris Lattner return; 1106b0fdedb3fd123a47e7deca75d1e6f7d64218b07aDevang Patel DebugLoc DL = MI->getDebugLoc(); 110753bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (DL.isUnknown()) 110853bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel return; 11096b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DILocation CurDLT = MF->getDILocation(DL); 11106b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel if (CurDLT.getScope().isNull()) 111153bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel return; 111253bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel 1113043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner if (!BeforePrintingInsn) { 111453bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel // After printing instruction 111553bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel DW->EndScope(MI); 1116043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner } else if (CurDLT.getNode() != PrevDLT) { 1117043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner unsigned L = DW->RecordSourceLine(CurDLT.getLineNumber(), 1118043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner CurDLT.getColumnNumber(), 1119043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner CurDLT.getScope().getNode()); 1120043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner printLabel(L); 1121043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner O << '\n'; 1122043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner DW->BeginScope(MI, L); 1123043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner PrevDLT = CurDLT.getNode(); 1124cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis } 1125cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis} 11263ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner 112753bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel 11280264d1a4777370009176157b76d116b3195e3767Chris Lattner/// printInlineAsm - This method formats and prints the specified machine 11290264d1a4777370009176157b76d116b3195e3767Chris Lattner/// instruction that is an inline asm. 11300264d1a4777370009176157b76d116b3195e3767Chris Lattnervoid AsmPrinter::printInlineAsm(const MachineInstr *MI) const { 1131f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner unsigned NumOperands = MI->getNumOperands(); 1132f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner 1133f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner // Count the number of register definitions. 1134f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner unsigned NumDefs = 0; 1135d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef(); 113667942f5dc30be1810f983aba8c94c49ca44e8634Chris Lattner ++NumDefs) 1137f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner assert(NumDefs != NumOperands-1 && "No asm string?"); 1138f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner 1139d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman assert(MI->getOperand(NumDefs).isSymbol() && "No asm string?"); 11406609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 11416609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Disassemble the AsmStr, printing out the literal pieces, the operands, etc. 1142f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner const char *AsmStr = MI->getOperand(NumDefs).getSymbolName(); 11436609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 114440c57860dad429d3c938ed5f918c2c66f3b5fa72Dan Gohman O << '\t'; 114540c57860dad429d3c938ed5f918c2c66f3b5fa72Dan Gohman 1146ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // If this asmstr is empty, just print the #APP/#NOAPP markers. 1147ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // These are useful to see where empty asm's wound up. 1148f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner if (AsmStr[0] == 0) { 114933adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmStart() << "\n\t"; 115033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmEnd() << '\n'; 1151f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner return; 1152f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner } 1153f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner 115433adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmStart() << "\n\t"; 1155f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner 1156eb9a42c90bf7e21ad8544315a65f86b668cc0277Bill Wendling // The variant of the current asmprinter. 115733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner int AsmPrinterVariant = MAI->getAssemblerDialect(); 1158eb9a42c90bf7e21ad8544315a65f86b668cc0277Bill Wendling 11596609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner int CurVariant = -1; // The number of the {.|.|.} region we are in. 11606609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *LastEmitted = AsmStr; // One past the last character emitted. 11612cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 11626609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner while (*LastEmitted) { 11636609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner switch (*LastEmitted) { 11646609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner default: { 11656609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Not a special case, emit the string section literally. 11666609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *LiteralEnd = LastEmitted+1; 11676609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && 11681c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') 11696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LiteralEnd; 11706609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 11716609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner O.write(LastEmitted, LiteralEnd-LastEmitted); 11726609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner LastEmitted = LiteralEnd; 11736609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 11746609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 11751c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner case '\n': 11761c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner ++LastEmitted; // Consume newline character. 1177d19a53ba1d4629f69821f37ca824c65e6df8e8f9Dan Gohman O << '\n'; // Indent code with newline. 11781c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner break; 11796609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner case '$': { 11806609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '$' character. 1181faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner bool Done = true; 1182faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner 1183faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner // Handle escapes. 1184faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner switch (*LastEmitted) { 1185faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner default: Done = false; break; 1186faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '$': // $$ -> $ 11876609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 11886609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner O << '$'; 11896609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume second '$' character. 11906609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 1191faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '(': // $( -> same as GCC's { character. 1192faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // Consume '(' character. 1193faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner if (CurVariant != -1) { 11947d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Nested variants found in inline asm string: '" 11957d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 1196faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner } 1197faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner CurVariant = 0; // We're in the first variant now. 1198faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 1199faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '|': 1200faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // consume '|' character. 12018b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen if (CurVariant == -1) 12028b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen O << '|'; // this is gcc's behavior for | outside a variant 12038b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen else 12048b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen ++CurVariant; // We're in the next variant. 1205faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 1206faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case ')': // $) -> same as GCC's } char. 1207faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // consume ')' character. 12088b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen if (CurVariant == -1) 12098b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen O << '}'; // this is gcc's behavior for } outside a variant 12108b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen else 12118b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen CurVariant = -1; 1212faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 12136609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1214faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner if (Done) break; 12156609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 12166609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner bool HasCurlyBraces = false; 12176609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (*LastEmitted == '{') { // ${variable} 12186609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '{' character. 12196609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner HasCurlyBraces = true; 12206609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12216609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 12223e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // If we have ${:foo}, then this is not a real operand reference, it is a 12233e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // "magic" string reference, just like in .td files. Arrange to call 12243e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // PrintSpecial. 12253e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner if (HasCurlyBraces && *LastEmitted == ':') { 12263e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner ++LastEmitted; 12273e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner const char *StrStart = LastEmitted; 12283e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner const char *StrEnd = strchr(StrStart, '}'); 12293e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner if (StrEnd == 0) { 12307d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Unterminated ${:foo} operand in inline asm string: '" 12317d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 12323e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner } 12333e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner 12343e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner std::string Val(StrStart, StrEnd); 12353e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner PrintSpecial(MI, Val.c_str()); 12363e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner LastEmitted = StrEnd+1; 12373e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner break; 12383e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner } 12393e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner 12406609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *IDStart = LastEmitted; 12416609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner char *IDEnd; 1242fad2912522a4c97128d8afcc2f40ca0e39287ddbChris Lattner errno = 0; 12436609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner long Val = strtol(IDStart, &IDEnd, 10); // We only accept numbers for IDs. 12446609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (!isdigit(*IDStart) || (Val == 0 && errno == EINVAL)) { 12457d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad $ operand number in inline asm string: '" 12467d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 12476609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12486609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner LastEmitted = IDEnd; 12496609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1250a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner char Modifier[2] = { 0, 0 }; 1251a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 12526609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (HasCurlyBraces) { 1253a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner // If we have curly braces, check for a modifier character. This 1254a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm. 1255a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner if (*LastEmitted == ':') { 1256a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner ++LastEmitted; // Consume ':' character. 1257a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner if (*LastEmitted == 0) { 12587d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad ${:} expression in inline asm string: '" 12597d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 1260a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner } 1261a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 1262a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner Modifier[0] = *LastEmitted; 1263a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner ++LastEmitted; // Consume modifier character. 1264a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner } 1265a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 12666609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (*LastEmitted != '}') { 12677d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad ${} expression in inline asm string: '" 12687d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 12696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12706609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '}' character. 12716609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12726609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 12736609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if ((unsigned)Val >= NumOperands-1) { 12747d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Invalid $ operand number in inline asm string: '" 12757d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 12766609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12776609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1278c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Okay, we finally have a value number. Ask the target to print this 12796609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // operand! 1280c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) { 1281c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned OpNo = 1; 1282fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1283fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner bool Error = false; 1284fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1285c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan to find the machine operand number for the operand. 1286daf6bc6347b4785102611bdf21c512e8a7678cceChris Lattner for (; Val; --Val) { 1287fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner if (OpNo >= MI->getNumOperands()) break; 12889e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned OpFlags = MI->getOperand(OpNo).getImm(); 1289697cbbfb00c318f98d6eb51945f077e2bfe8781eEvan Cheng OpNo += InlineAsm::getNumOperandRegisters(OpFlags) + 1; 1290daf6bc6347b4785102611bdf21c512e8a7678cceChris Lattner } 1291fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1292fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner if (OpNo >= MI->getNumOperands()) { 1293fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner Error = true; 1294dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner } else { 12959e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned OpFlags = MI->getOperand(OpNo).getImm(); 1296fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner ++OpNo; // Skip over the ID number. 1297fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 129810b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner if (Modifier[0] == 'l') // labels are target independent 129910b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner O << *GetMBBSymbol(MI->getOperand(OpNo).getMBB()->getNumber()); 1300eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen else { 1301eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen AsmPrinter *AP = const_cast<AsmPrinter*>(this); 130286b49f8e2de796cb46c7c8b6a4c4900533fd53f4Dale Johannesen if ((OpFlags & 7) == 4) { 1303eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Error = AP->PrintAsmMemoryOperand(MI, OpNo, AsmPrinterVariant, 1304eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Modifier[0] ? Modifier : 0); 1305eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } else { 1306eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Error = AP->PrintAsmOperand(MI, OpNo, AsmPrinterVariant, 1307eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Modifier[0] ? Modifier : 0); 1308eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } 1309fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner } 1310dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner } 1311dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner if (Error) { 13127d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin std::string msg; 13137d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin raw_string_ostream Msg(msg); 131410b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner Msg << "Invalid operand found in inline asm: '" << AsmStr << "'\n"; 13157d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin MI->print(Msg); 13167d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error(Msg.str()); 13176609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1318c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 13196609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 13206609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13216609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13226609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1323c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << "\n\t" << MAI->getCommentString() << MAI->getInlineAsmEnd(); 13246609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner} 13256609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1326da47e6e0d003c873da960361549e57ee4617c301Evan Cheng/// printImplicitDef - This method prints the specified machine instruction 1327da47e6e0d003c873da960361549e57ee4617c301Evan Cheng/// that is an implicit def. 1328da47e6e0d003c873da960361549e57ee4617c301Evan Chengvoid AsmPrinter::printImplicitDef(const MachineInstr *MI) const { 1329c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner if (!VerboseAsm) return; 1330c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O.PadToColumn(MAI->getCommentColumn()); 1331c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << MAI->getCommentString() << " implicit-def: " 1332f806c23a9a297e0b6d19d82ed23c6c5921d6ecd9Chris Lattner << TRI->getName(MI->getOperand(0).getReg()); 1333da47e6e0d003c873da960361549e57ee4617c301Evan Cheng} 1334da47e6e0d003c873da960361549e57ee4617c301Evan Cheng 1335ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesenvoid AsmPrinter::printKill(const MachineInstr *MI) const { 1336ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen if (!VerboseAsm) return; 1337ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O.PadToColumn(MAI->getCommentColumn()); 1338ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O << MAI->getCommentString() << " kill:"; 1339ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen for (unsigned n = 0, e = MI->getNumOperands(); n != e; ++n) { 1340ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen const MachineOperand &op = MI->getOperand(n); 1341ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen assert(op.isReg() && "KILL instruction must have only register operands"); 1342ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O << ' ' << TRI->getName(op.getReg()) << (op.isDef() ? "<def>" : "<kill>"); 1343ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen } 1344ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen} 1345ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen 13461ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey/// printLabel - This method prints a local label used by debug and 13471ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey/// exception handling tables. 13481ee29257428960fede862fcfdbe80d5d007927e9Jim Laskeyvoid AsmPrinter::printLabel(const MachineInstr *MI) const { 1349528bc028774513ee76125f85ceb8f704f5901cc8Dan Gohman printLabel(MI->getOperand(0).getImm()); 13501ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey} 13511ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey 13521b08bbca5592351a940bcd164bdec724ee954326Evan Chengvoid AsmPrinter::printLabel(unsigned Id) const { 1353c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << MAI->getPrivateGlobalPrefix() << "label" << Id << ':'; 13541b08bbca5592351a940bcd164bdec724ee954326Evan Cheng} 13551b08bbca5592351a940bcd164bdec724ee954326Evan Cheng 13566609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner/// PrintAsmOperand - Print the specified operand of MI, an INLINEASM 13576609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner/// instruction, using the specified assembler variant. Targets should 1358cf0b76649be4eea33aba783d4154ea338b7cbbc2Dale Johannesen/// override this to format as appropriate. 13596609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattnerbool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 1360a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner unsigned AsmVariant, const char *ExtraCode) { 13616609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Target doesn't support this yet! 13626609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner return true; 13630264d1a4777370009176157b76d116b3195e3767Chris Lattner} 1364dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner 1365dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattnerbool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 1366dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner unsigned AsmVariant, 1367dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner const char *ExtraCode) { 1368dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner // Target doesn't support this yet! 1369dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner return true; 1370dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner} 137137efe6764568a3829fee26aba532283131d1a104Nate Begeman 137229cbade25aa094ca9a149a96a8614cf6f3247480Dan GohmanMCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA, 137329cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman const char *Suffix) const { 137429cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman return GetBlockAddressSymbol(BA->getFunction(), BA->getBasicBlock(), Suffix); 13758c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman} 13768c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 13778c2b52552c90f39e4b2fed43e309e599e742b6acDan GohmanMCSymbol *AsmPrinter::GetBlockAddressSymbol(const Function *F, 137829cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman const BasicBlock *BB, 137929cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman const char *Suffix) const { 13808c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman assert(BB->hasName() && 13818c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman "Address of anonymous basic block not supported yet!"); 13828c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 1383568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // This code must use the function name itself, and not the function number, 1384568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // since it must be possible to generate the label name from within other 1385568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // functions. 13862f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner SmallString<60> FnName; 13872f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mang->getNameWithPrefix(FnName, F, false); 13888c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 13892f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner // FIXME: THIS IS BROKEN IF THE LLVM BASIC BLOCK DOESN'T HAVE A NAME! 13904813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner SmallString<60> NameResult; 13912f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mang->getNameWithPrefix(NameResult, 13922f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner StringRef("BA") + Twine((unsigned)FnName.size()) + 13932f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner "_" + FnName.str() + "_" + BB->getName() + Suffix, 13942f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mangler::Private); 13954813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner 13964813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner return OutContext.GetOrCreateSymbol(NameResult.str()); 13978c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman} 13988c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 13997cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris LattnerMCSymbol *AsmPrinter::GetMBBSymbol(unsigned MBBID) const { 14007cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner SmallString<60> Name; 14017cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "BB" 14027cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner << getFunctionNumber() << '_' << MBBID; 14033924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner return OutContext.GetOrCreateSymbol(Name.str()); 14043924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner} 14053924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 14063924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner/// GetCPISymbol - Return the symbol for the specified constant pool entry. 14073924868a957d5a6d468b61741cbb7db77324d1f6Chris LattnerMCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { 14083924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner SmallString<60> Name; 14093924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "CPI" 14103924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner << getFunctionNumber() << '_' << CPID; 14113924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner return OutContext.GetOrCreateSymbol(Name.str()); 14123924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner} 14133924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 14143924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner/// GetJTISymbol - Return the symbol for the specified jump table entry. 14153924868a957d5a6d468b61741cbb7db77324d1f6Chris LattnerMCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { 14163924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner const char *Prefix = isLinkerPrivate ? MAI->getLinkerPrivateGlobalPrefix() : 14173924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner MAI->getPrivateGlobalPrefix(); 14183924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner SmallString<60> Name; 14193924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner raw_svector_ostream(Name) << Prefix << "JTI" << getFunctionNumber() << '_' 14203924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner << JTID; 14217cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner return OutContext.GetOrCreateSymbol(Name.str()); 14227cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner} 14237cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner 14246b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// GetGlobalValueSymbol - Return the MCSymbol for the specified global 14256b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// value. 14266b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris LattnerMCSymbol *AsmPrinter::GetGlobalValueSymbol(const GlobalValue *GV) const { 14276b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner SmallString<60> NameStr; 14286b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner Mang->getNameWithPrefix(NameStr, GV, false); 14296b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 14306b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner} 14316b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner 14327a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner/// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with 1433d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner/// global value name as its base, with the specified suffix, and where the 14347a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner/// symbol is forced to have private linkage if ForcePrivate is true. 14357a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris LattnerMCSymbol *AsmPrinter::GetSymbolWithGlobalValueBase(const GlobalValue *GV, 14367a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner StringRef Suffix, 14377a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner bool ForcePrivate) const { 1438d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner SmallString<60> NameStr; 14397a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner Mang->getNameWithPrefix(NameStr, GV, ForcePrivate); 1440d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner NameStr.append(Suffix.begin(), Suffix.end()); 1441d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 1442d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner} 1443d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner 14446b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// GetExternalSymbolSymbol - Return the MCSymbol for the specified 14456b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// ExternalSymbol. 14466b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris LattnerMCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const { 14476b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner SmallString<60> NameStr; 14486b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner Mang->getNameWithPrefix(NameStr, Sym); 14496b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 14506b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner} 14516b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner 14527cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner 1453523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1454523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// PrintParentLoopComment - Print comments about parent loops of this one. 1455523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1456523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner unsigned FunctionNumber) { 1457523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop == 0) return; 1458523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber); 1459523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent(Loop->getLoopDepth()*2) 1460523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << "Parent Loop BB" << FunctionNumber << "_" 1461523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << Loop->getHeader()->getNumber() 1462523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << " Depth=" << Loop->getLoopDepth() << '\n'; 1463523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1464523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1465523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1466523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// PrintChildLoopComment - Print comments about child loops within 1467523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// the loop for this basic block, with nesting. 1468523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1469523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner unsigned FunctionNumber) { 1470523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Add child loop information 1471523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner for (MachineLoop::iterator CL = Loop->begin(), E = Loop->end();CL != E; ++CL){ 1472523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent((*CL)->getLoopDepth()*2) 1473523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << "Child Loop BB" << FunctionNumber << "_" 1474523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << (*CL)->getHeader()->getNumber() << " Depth " << (*CL)->getLoopDepth() 1475523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << '\n'; 1476523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintChildLoopComment(OS, *CL, FunctionNumber); 1477523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner } 1478523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1479523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1480523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// EmitComments - Pretty-print comments for basic blocks. 1481523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintBasicBlockLoopComments(const MachineBasicBlock &MBB, 1482523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const MachineLoopInfo *LI, 1483523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const AsmPrinter &AP) { 1484523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Add loop depth information 1485523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const MachineLoop *Loop = LI->getLoopFor(&MBB); 1486523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop == 0) return; 1487523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1488523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner MachineBasicBlock *Header = Loop->getHeader(); 1489523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner assert(Header && "No header for loop"); 1490523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1491523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // If this block is not a loop header, just print out what is the loop header 1492523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // and return. 1493523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Header != &MBB) { 1494523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner AP.OutStreamer.AddComment(" in Loop: Header=BB" + 1495523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner Twine(AP.getFunctionNumber())+"_" + 1496523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner Twine(Loop->getHeader()->getNumber())+ 1497523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner " Depth="+Twine(Loop->getLoopDepth())); 1498523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner return; 1499523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner } 1500523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1501523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Otherwise, it is a loop header. Print out information about child and 1502523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // parent loops. 1503523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner raw_ostream &OS = AP.OutStreamer.GetCommentOS(); 1504523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1505523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber()); 1506523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1507523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "=>"; 1508523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent(Loop->getLoopDepth()*2-2); 1509523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1510523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "This "; 1511523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop->empty()) 1512523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "Inner "; 1513523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n'; 1514523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1515523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); 1516523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1517523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1518523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 151970a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// EmitBasicBlockStart - This method prints the label for the specified 152070a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// MachineBasicBlock, an alignment (if present) and a comment describing 152170a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// it if appropriate. 1522662316c997e4eb8c3fdec6999b3e9da03620847aChris Lattnervoid AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock *MBB) const { 1523b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // Emit an alignment directive for this block, if needed. 152470a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner if (unsigned Align = MBB->getAlignment()) 152570a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner EmitAlignment(Log2_32(Align)); 1526fb8075d03f5c87bd57dcc9c5f2304f6b13c55aadEvan Cheng 1527b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // If the block has its address taken, emit a special label to satisfy 1528b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // references to the block. This is done so that we don't need to 1529b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // remember the number of this label, and so that we can make 1530b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // forward references to labels without knowing what their numbers 1531b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // will be. 15328c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman if (MBB->hasAddressTaken()) { 1533213168ba469703a186d060281e587d828878aa75Chris Lattner const BasicBlock *BB = MBB->getBasicBlock(); 15340fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) 15350fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("Address Taken"); 1536213168ba469703a186d060281e587d828878aa75Chris Lattner OutStreamer.EmitLabel(GetBlockAddressSymbol(BB->getParent(), BB)); 15378c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman } 15388c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 1539b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // Print the main label for the block. 1540e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman if (MBB->pred_empty() || MBB->isOnlyReachableByFallthrough()) { 15410fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) { 15423a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner // NOTE: Want this comment at start of line. 1543e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman O << MAI->getCommentString() << " BB#" << MBB->getNumber() << ':'; 15440fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (const BasicBlock *BB = MBB->getBasicBlock()) 15450fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (BB->hasName()) 15460fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("%" + BB->getName()); 1547d8d0aee26a5a759085bfa9114302e507c8685599Chris Lattner 1548523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintBasicBlockLoopComments(*MBB, LI, *this); 15490fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddBlankLine(); 15500fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner } 1551e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman } else { 15520fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) { 15530fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (const BasicBlock *BB = MBB->getBasicBlock()) 15540fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (BB->hasName()) 15550fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("%" + BB->getName()); 1556523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintBasicBlockLoopComments(*MBB, LI, *this); 15570fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner } 1558d8d0aee26a5a759085bfa9114302e507c8685599Chris Lattner 1559213168ba469703a186d060281e587d828878aa75Chris Lattner OutStreamer.EmitLabel(GetMBBSymbol(MBB->getNumber())); 1560e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman } 156137efe6764568a3829fee26aba532283131d1a104Nate Begeman} 156252a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 1563cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng/// printPICJumpTableSetLabel - This method prints a set label for the 1564cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng/// specified MachineBasicBlock for a jumptable entry. 1565cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Chengvoid AsmPrinter::printPICJumpTableSetLabel(unsigned uid, 1566cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng const MachineBasicBlock *MBB) const { 156733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (!MAI->getSetDirective()) 156852a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman return; 156952a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 157033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getSetDirective() << ' ' << MAI->getPrivateGlobalPrefix() 157110b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner << getFunctionNumber() << '_' << uid << "_set_" << MBB->getNumber() << ',' 157210b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner << *GetMBBSymbol(MBB->getNumber()) 15733924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner << '-' << *GetJTISymbol(uid) << '\n'; 157452a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman} 1575d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 1576cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Chengvoid AsmPrinter::printPICJumpTableSetLabel(unsigned uid, unsigned uid2, 1577cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng const MachineBasicBlock *MBB) const { 157833adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (!MAI->getSetDirective()) 157941349c10cbb166c58a20896e4761455f001c611eEvan Cheng return; 158041349c10cbb166c58a20896e4761455f001c611eEvan Cheng 158133adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getSetDirective() << ' ' << MAI->getPrivateGlobalPrefix() 1582347d39f1fd8ad825a7ec5b8a3dce816723a56d42Evan Cheng << getFunctionNumber() << '_' << uid << '_' << uid2 158310b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner << "_set_" << MBB->getNumber() << ',' 158410b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner << *GetMBBSymbol(MBB->getNumber()) 158510b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner << '-' << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() 1586347d39f1fd8ad825a7ec5b8a3dce816723a56d42Evan Cheng << '_' << uid << '_' << uid2 << '\n'; 158741349c10cbb166c58a20896e4761455f001c611eEvan Cheng} 158841349c10cbb166c58a20896e4761455f001c611eEvan Cheng 1589152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattnervoid AsmPrinter::printVisibility(MCSymbol *Sym, unsigned Visibility) const { 1590152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner MCSymbolAttr Attr = MCSA_Invalid; 1591152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner 1592152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner switch (Visibility) { 1593152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner default: break; 1594152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner case GlobalValue::HiddenVisibility: 1595152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner Attr = MAI->getHiddenVisibilityAttr(); 1596152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner break; 1597152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner case GlobalValue::ProtectedVisibility: 1598152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner Attr = MAI->getProtectedVisibilityAttr(); 1599152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner break; 160053d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner } 1601152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner 1602152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner if (Attr != MCSA_Invalid) 1603152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner OutStreamer.EmitSymbolAttribute(Sym, Attr); 160453d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner} 160553d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner 16067751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikovvoid AsmPrinter::printOffset(int64_t Offset) const { 16077751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov if (Offset > 0) 16087751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov O << '+' << Offset; 16097751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov else if (Offset < 0) 16107751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov O << Offset; 16117751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov} 16127751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov 16135eca075b74d62c621b160aa216b4cd50829a2cc7Gordon HenriksenGCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy *S) { 16145eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (!S->usesMetadata()) 1615c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen return 0; 1616c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 16175eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen gcp_iterator GCPI = GCMetadataPrinters.find(S); 1618c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen if (GCPI != GCMetadataPrinters.end()) 1619c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen return GCPI->second; 1620c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 16215eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen const char *Name = S->getName().c_str(); 1622c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 1623c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen for (GCMetadataPrinterRegistry::iterator 1624c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen I = GCMetadataPrinterRegistry::begin(), 1625c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen E = GCMetadataPrinterRegistry::end(); I != E; ++I) 1626c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen if (strcmp(Name, I->getName()) == 0) { 16275eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCMetadataPrinter *GMP = I->instantiate(); 16285eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GMP->S = S; 16295eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCMetadataPrinters.insert(std::make_pair(S, GMP)); 16305eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen return GMP; 1631c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen } 1632c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 163352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner llvm_report_error("no GCMetadataPrinter registered for GC: " + Twine(Name)); 163452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return 0; 1635c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen} 1636014700c1a8cba203fd21ff129426ba8a426ab244David Greene 1637014700c1a8cba203fd21ff129426ba8a426ab244David Greene/// EmitComments - Pretty-print comments for instructions 16385f51cd057984b89e0dc0812d45d512596a3c6596Chris Lattnervoid AsmPrinter::EmitComments(const MachineInstr &MI) const { 16391924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene if (!VerboseAsm) 16401924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene return; 16415f51cd057984b89e0dc0812d45d512596a3c6596Chris Lattner 16421924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene bool Newline = false; 16431924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene 16441924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene if (!MI.getDebugLoc().isUnknown()) { 16456b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DILocation DLT = MF->getDILocation(MI.getDebugLoc()); 16461924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene 16471924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene // Print source line info. 16481924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene O.PadToColumn(MAI->getCommentColumn()); 16493b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman O << MAI->getCommentString() << ' '; 16506b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DIScope Scope = DLT.getScope(); 16513b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman // Omit the directory, because it's likely to be long and uninteresting. 16523b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman if (!Scope.isNull()) 16533b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman O << Scope.getFilename(); 16543b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman else 16553b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman O << "<unknown>"; 16566b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel O << ':' << DLT.getLineNumber(); 16576b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel if (DLT.getColumnNumber() != 0) 16586b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel O << ':' << DLT.getColumnNumber(); 16591924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene Newline = true; 16603ac1ab835caacdeebbd0d7b4d69160f283928d21David Greene } 16611924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene 1662ddff941357bd836243ed7004ab88db09490176d8David Greene // Check for spills and reloads 1663ddff941357bd836243ed7004ab88db09490176d8David Greene int FI; 1664ddff941357bd836243ed7004ab88db09490176d8David Greene 1665ddff941357bd836243ed7004ab88db09490176d8David Greene const MachineFrameInfo *FrameInfo = 1666ddff941357bd836243ed7004ab88db09490176d8David Greene MI.getParent()->getParent()->getFrameInfo(); 1667ddff941357bd836243ed7004ab88db09490176d8David Greene 1668ddff941357bd836243ed7004ab88db09490176d8David Greene // We assume a single instruction only has a spill or reload, not 1669ddff941357bd836243ed7004ab88db09490176d8David Greene // both. 1670f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene const MachineMemOperand *MMO; 1671ddff941357bd836243ed7004ab88db09490176d8David Greene if (TM.getInstrInfo()->isLoadFromStackSlotPostFE(&MI, FI)) { 1672ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1673f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene MMO = *MI.memoperands_begin(); 1674ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1675ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1676fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' << MMO->getSize() << "-byte Reload"; 1677ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1678ddff941357bd836243ed7004ab88db09490176d8David Greene } 1679ddff941357bd836243ed7004ab88db09490176d8David Greene } 1680f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene else if (TM.getInstrInfo()->hasLoadFromStackSlot(&MI, MMO, FI)) { 1681ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1682ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1683ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1684fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' 1685fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman << MMO->getSize() << "-byte Folded Reload"; 1686ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1687ddff941357bd836243ed7004ab88db09490176d8David Greene } 1688ddff941357bd836243ed7004ab88db09490176d8David Greene } 1689ddff941357bd836243ed7004ab88db09490176d8David Greene else if (TM.getInstrInfo()->isStoreToStackSlotPostFE(&MI, FI)) { 1690ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1691f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene MMO = *MI.memoperands_begin(); 1692ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1693ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1694fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' << MMO->getSize() << "-byte Spill"; 1695ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1696ddff941357bd836243ed7004ab88db09490176d8David Greene } 1697ddff941357bd836243ed7004ab88db09490176d8David Greene } 1698f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene else if (TM.getInstrInfo()->hasStoreToStackSlot(&MI, MMO, FI)) { 1699ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1700ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1701ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1702fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' 1703fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman << MMO->getSize() << "-byte Folded Spill"; 1704ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1705ddff941357bd836243ed7004ab88db09490176d8David Greene } 1706ddff941357bd836243ed7004ab88db09490176d8David Greene } 1707ddff941357bd836243ed7004ab88db09490176d8David Greene 1708ddff941357bd836243ed7004ab88db09490176d8David Greene // Check for spill-induced copies 1709ddff941357bd836243ed7004ab88db09490176d8David Greene unsigned SrcReg, DstReg, SrcSubIdx, DstSubIdx; 1710ddff941357bd836243ed7004ab88db09490176d8David Greene if (TM.getInstrInfo()->isMoveInstr(MI, SrcReg, DstReg, 1711ddff941357bd836243ed7004ab88db09490176d8David Greene SrcSubIdx, DstSubIdx)) { 1712ddff941357bd836243ed7004ab88db09490176d8David Greene if (MI.getAsmPrinterFlag(ReloadReuse)) { 1713ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1714ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1715ddff941357bd836243ed7004ab88db09490176d8David Greene O << MAI->getCommentString() << " Reload Reuse"; 1716ddff941357bd836243ed7004ab88db09490176d8David Greene } 1717ddff941357bd836243ed7004ab88db09490176d8David Greene } 1718014700c1a8cba203fd21ff129426ba8a426ab244David Greene} 1719014700c1a8cba203fd21ff129426ba8a426ab244David Greene 1720