AsmPrinter.cpp revision 2cf7251d39f28888af06b6f941eabd1d10995382
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) 67b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner : MachineFunctionPass(&ID), 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 90b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner/// getFunctionNumber - Return a unique ID for the current function. 91b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner/// 92b84822fb7b64977c16e97b870891da1d6c9736feChris Lattnerunsigned AsmPrinter::getFunctionNumber() const { 93b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner return MF->getFunctionNumber(); 94b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner} 95b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner 9638c398808cff7defdf013fa750dfac8e66302975Chris LattnerTargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { 97f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner return TM.getTargetLowering()->getObjFileLowering(); 98f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner} 99f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner 100dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner/// getCurrentSection() - Return the current section we are emitting to. 101dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattnerconst MCSection *AsmPrinter::getCurrentSection() const { 102dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner return OutStreamer.getCurrentSection(); 103b5a32e2e8ce2f3de3a340c5a2dfcd3a159968466Anton Korobeynikov} 1044632d7a57008564c4b0f8246e85bd813a200d2c6Chris Lattner 105dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner 106ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksenvoid AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { 107845012e6d31799c7fbd1193fa1af8ee2d12e9231Dan Gohman AU.setPreservesAll(); 108ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen MachineFunctionPass::getAnalysisUsage(AU); 1095eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen AU.addRequired<GCModuleInfo>(); 110fe37ab335be5632eab561d49984c95cb06b946d4David Greene if (VerboseAsm) 111b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene AU.addRequired<MachineLoopInfo>(); 112ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen} 113ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 114a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerbool AsmPrinter::doInitialization(Module &M) { 115f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner // Initialize TargetLoweringObjectFile. 116f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner const_cast<TargetLoweringObjectFile&>(getObjFileLowering()) 117f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner .Initialize(OutContext, TM); 118f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner 119c0dba723d119adc8c7b49c6d0e97d10eac4428fcChris Lattner Mang = new Mangler(*MAI); 1202c1b1597f244c836771b4f2668c0ae399d32a5e9Chris Lattner 121812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson // Allow the target to emit any magic that it wants at the start of the file. 122812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson EmitStartOfAsmFile(M); 123952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola 124a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner // Very minimal debug info. It is ignored if we emit actual debug info. If we 125a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner // don't, this at least helps the user find where a global came from. 12633adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->hasSingleParameterDotFile()) { 127a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner // .file "foo.c" 128a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner OutStreamer.EmitFileDirective(M.getModuleIdentifier()); 129952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola } 130952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola 131812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 132812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 1335eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I) 1345eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) 13533adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MP->beginAssembly(O, *this, *MAI); 136ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 1373e2fa7a746270452316523f27b9055b007feba32Chris Lattner if (!M.getModuleInlineAsm().empty()) 13833adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << " Start of file scope inline assembly\n" 1393e2fa7a746270452316523f27b9055b007feba32Chris Lattner << M.getModuleInlineAsm() 14033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner << '\n' << MAI->getCommentString() 141563321a2582851c653d0863e8e0bba3d483734f9Jim Laskey << " End of file scope inline assembly\n"; 1422c1b1597f244c836771b4f2668c0ae399d32a5e9Chris Lattner 143b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner MMI = getAnalysisIfAvailable<MachineModuleInfo>(); 144b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner if (MMI) 145b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner MMI->AnalyzeModule(M); 146b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner DW = getAnalysisIfAvailable<DwarfWriter>(); 1479a501cf19dbf1f56f0782ddba4c1931565af9610Sanjiv Gupta if (DW) 148b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner DW->BeginModule(&M, MMI, O, this, MAI); 14914a55d952cf238fff42da53a75f39cf06dab184bDevang Patel 150a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner return false; 151a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 152a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 153a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattnervoid AsmPrinter::EmitLinkage(unsigned Linkage, MCSymbol *GVSym) { 154a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner switch ((GlobalValue::LinkageTypes)Linkage) { 155a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::CommonLinkage: 156a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::LinkOnceAnyLinkage: 157a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::LinkOnceODRLinkage: 158a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::WeakAnyLinkage: 159a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::WeakODRLinkage: 160a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::LinkerPrivateLinkage: 161a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner if (MAI->getWeakDefDirective() != 0) { 162a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .globl _foo 163a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 164a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .weak_definition _foo 165a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefinition); 166a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } else if (const char *LinkOnce = MAI->getLinkOnceDirective()) { 167a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .globl _foo 168a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 169a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // FIXME: linkonce should be a section attribute, handled by COFF Section 170a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // assignment. 171a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // http://sourceware.org/binutils/docs-2.20/as/Linkonce.html#Linkonce 172111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner // .linkonce discard 173111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner // FIXME: It would be nice to use .linkonce samesize for non-common 174111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner // globals. 175a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner O << LinkOnce; 176a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } else { 177a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .weak _foo 178a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); 179a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } 180a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner break; 181a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::DLLExportLinkage: 182a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::AppendingLinkage: 183a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // FIXME: appending linkage variables should go into a section of 184a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // their name or something. For now, just emit them as external. 185a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::ExternalLinkage: 186a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // If external or appending, declare as a global symbol. 187a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .globl _foo 188a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 189a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner break; 190a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::PrivateLinkage: 191a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::InternalLinkage: 192a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner break; 193a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner default: 194a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner llvm_unreachable("Unknown linkage type!"); 195a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } 196a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner} 197a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner 198a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner 19948d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner/// EmitGlobalVariable - Emit the specified global variable to the .s file. 20048d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattnervoid AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { 20148d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner if (!GV->hasInitializer()) // External globals require no code. 20248d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner return; 20348d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 20448d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner // Check to see if this is a special global used by LLVM, if so, emit it. 20548d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner if (EmitSpecialLLVMGlobal(GV)) 20648d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner return; 20774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 20874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner MCSymbol *GVSym = GetGlobalValueSymbol(GV); 20974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner printVisibility(GVSym, GV->getVisibility()); 21074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 211a800f7c464ef9a376057a555129f36d1f8488c3bChris Lattner if (MAI->hasDotTypeDotSizeDirective()) 212a800f7c464ef9a376057a555129f36d1f8488c3bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); 21374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 21474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM); 21574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 21674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner const TargetData *TD = TM.getTargetData(); 21774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner unsigned Size = TD->getTypeAllocSize(GV->getType()->getElementType()); 21874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner unsigned AlignLog = TD->getPreferredAlignmentLog(GV); 21974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 2209744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner // Handle common and BSS local symbols (.lcomm). 2219744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner if (GVKind.isCommon() || GVKind.isBSSLocal()) { 22274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. 22374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 22474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (VerboseAsm) { 2250fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), GV, 2260fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner /*PrintType=*/false, GV->getParent()); 2270fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << '\n'; 22874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 229814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 230814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // Handle common symbols. 2319744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner if (GVKind.isCommon()) { 2329744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner // .comm _foo, 42, 4 2334ed5438f4882c9fe779b1a8ff546877889b222dfChris Lattner OutStreamer.EmitCommonSymbol(GVSym, Size, 1 << AlignLog); 234814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 235814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner } 236814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 237814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // Handle local BSS symbols. 238814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner if (MAI->hasMachoZeroFillDirective()) { 239814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner const MCSection *TheSection = 240814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 241814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .zerofill __DATA, __bss, _foo, 400, 5 242814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 243814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 244814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner } 245814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 2469eb158d5b4cd4f6fc80912e2dd77bdf13c3ca0e7Chris Lattner if (MAI->hasLCOMMDirective()) { 247814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .lcomm _foo, 42 2489eb158d5b4cd4f6fc80912e2dd77bdf13c3ca0e7Chris Lattner OutStreamer.EmitLocalCommonSymbol(GVSym, Size); 249814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 25074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 251814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 252814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .local _foo 253a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Local); 254814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .comm _foo, 42, 4 255814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner OutStreamer.EmitCommonSymbol(GVSym, Size, 1 << AlignLog); 25674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner return; 25774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 25848d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 25974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner const MCSection *TheSection = 26074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 26174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 26274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // Handle the zerofill directive on darwin, which is a special form of BSS 26374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // emission. 26474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (GVKind.isBSSExtern() && MAI->hasMachoZeroFillDirective()) { 26574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .globl _foo 266a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 26774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .zerofill __DATA, __common, _foo, 400, 5 26874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 26974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner return; 27074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 27174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 27274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner OutStreamer.SwitchSection(TheSection); 27374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 274a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner EmitLinkage(GV->getLinkage(), GVSym); 27574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner EmitAlignment(AlignLog, GV); 276a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner 27774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (VerboseAsm) { 2780fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), GV, 2790fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner /*PrintType=*/false, GV->getParent()); 2800fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << '\n'; 28174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 2824c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner OutStreamer.EmitLabel(GVSym); 28374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 28474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner EmitGlobalConstant(GV->getInitializer()); 28574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 28674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (MAI->hasDotTypeDotSizeDirective()) 2871947f242d40227d36440a2702a0a612c8077d72eChris Lattner // .size foo, 42 28899328add833807f12a4950c7de29fb2a5df04703Chris Lattner OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext)); 2890fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner 2900fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddBlankLine(); 29148d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner} 29248d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 293b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner/// EmitFunctionHeader - This method emits the header for the current 294b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner/// function. 295b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattnervoid AsmPrinter::EmitFunctionHeader() { 296b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Print out constants referenced by the function 297b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner EmitConstantPool(MF->getConstantPool()); 298b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 299b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Print the 'header' of function. 300b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner const Function *F = MF->getFunction(); 301b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 302b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); 303b406a8141d704bca7a8eade3a0c46d7ec73affc8Chris Lattner printVisibility(CurrentFnSym, F->getVisibility()); 304b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 305111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner EmitLinkage(F->getLinkage(), CurrentFnSym); 306b406a8141d704bca7a8eade3a0c46d7ec73affc8Chris Lattner EmitAlignment(MF->getAlignment(), F); 307b406a8141d704bca7a8eade3a0c46d7ec73affc8Chris Lattner 308b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (MAI->hasDotTypeDotSizeDirective()) 309b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner OutStreamer.EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction); 310b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 311b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (VerboseAsm) { 3129bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), F, 3139bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner /*PrintType=*/false, F->getParent()); 3149bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner OutStreamer.GetCommentOS() << '\n'; 315b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner } 316b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 3172cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner // Emit the CurrentFnSym. This is is a virtual function to allow targets to 3182cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner // do their wild and crazy things as required. 3192cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner EmitFunctionEntryLabel(); 3202cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner 321b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Add some workaround for linkonce linkage on Cygwin\MinGW. 322b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (MAI->getLinkOnceDirective() != 0 && 323b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner (F->hasLinkOnceLinkage() || F->hasWeakLinkage())) 3249bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner // FIXME: What is this? 325b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner O << "Lllvm$workaround$fake$stub$" << *CurrentFnSym << ":\n"; 326b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 327b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Emit pre-function debug and/or EH information. 328b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (MAI->doesSupportDebugInformation() || MAI->doesSupportExceptionHandling()) 329b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner DW->BeginFunction(MF); 330b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner} 331b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 3322cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the 3332cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner/// function. This can be overridden by targets as required to do custom stuff. 3342cf7251d39f28888af06b6f941eabd1d10995382Chris Lattnervoid AsmPrinter::EmitFunctionEntryLabel() { 3352cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner OutStreamer.EmitLabel(CurrentFnSym); 3362cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner} 337b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 33848d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 339a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerbool AsmPrinter::doFinalization(Module &M) { 34040bbebde9d250b875a47a688d0c6552834ada48fChris Lattner // Emit global variables. 34140bbebde9d250b875a47a688d0c6552834ada48fChris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 34240bbebde9d250b875a47a688d0c6552834ada48fChris Lattner I != E; ++I) 34348d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner EmitGlobalVariable(I); 34440bbebde9d250b875a47a688d0c6552834ada48fChris Lattner 3451f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner // Emit final debug information. 34633adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->doesSupportDebugInformation() || MAI->doesSupportExceptionHandling()) 3471f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner DW->EndModule(); 3481f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner 3490a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // If the target wants to know about weak references, print them all. 35033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->getWeakRefDirective()) { 3510a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // FIXME: This is not lazy, it would be nice to only print weak references 3520a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // to stuff that is actually used. Note that doing so would require targets 3530a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // to notice uses in operands (due to constant exprs etc). This should 3540a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // happen with the MC stuff eventually. 3550a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner 3560a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // Print out module-level global variables here. 3570a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 3580a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner I != E; ++I) { 35908ce3b473d06e0f7806df3d44b7b36ac40c58803Chris Lattner if (!I->hasExternalWeakLinkage()) continue; 3603924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(I), 361a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_WeakReference); 3620a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner } 3630a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner 364c6fdced3dbfdf673cc9b01dfad4f08e316d8803dChris Lattner for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 36508ce3b473d06e0f7806df3d44b7b36ac40c58803Chris Lattner if (!I->hasExternalWeakLinkage()) continue; 3663924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(I), 367a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_WeakReference); 3680a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner } 36915404d060ba8b604c03b9223a0f2e2abcd0fddedRafael Espindola } 37015404d060ba8b604c03b9223a0f2e2abcd0fddedRafael Espindola 371cee63322eaccc2f1067bdf5eab506e440f867da1Chris Lattner if (MAI->hasSetDirective()) { 3723a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.AddBlankLine(); 3738b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 3740a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner I != E; ++I) { 3755c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner MCSymbol *Name = GetGlobalValueSymbol(I); 376325be7c608a37d87e4f3d731e11fa3dd34f529b5Anton Korobeynikov 377325be7c608a37d87e4f3d731e11fa3dd34f529b5Anton Korobeynikov const GlobalValue *GV = cast<GlobalValue>(I->getAliasedGlobal()); 3785c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner MCSymbol *Target = GetGlobalValueSymbol(GV); 3795c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner 38010b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner if (I->hasExternalLinkage() || !MAI->getWeakRefDirective()) 381a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(Name, MCSA_Global); 38210b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner else if (I->hasWeakLinkage()) 383a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(Name, MCSA_WeakReference); 38410b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner else 38510595490ccf25b4960936638fac7a673eaf82e68Chris Lattner assert(I->hasLocalLinkage() && "Invalid alias linkage"); 38622c9e65643e0c6b43be37a19e59491ef0081092cAnton Korobeynikov 387541af7f769c89de8a7f52d563cf317ad7a86c245Anton Korobeynikov printVisibility(Name, I->getVisibility()); 38822c9e65643e0c6b43be37a19e59491ef0081092cAnton Korobeynikov 389c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner // Emit the directives as assignments aka .set: 390c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner OutStreamer.EmitAssignment(Name, 391c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner MCSymbolRefExpr::Create(Target, OutContext)); 3928b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 3938b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 3948b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 3951465d61bdd36cfd6021036a527895f0dd358e97dDuncan Sands GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 3965eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 3975eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) 3985eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*--I)) 39933adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MP->finishAssembly(O, *this, *MAI); 400ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 401a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman // If we don't have any trampolines, then we don't require stack memory 402a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman // to be executable. Some targets have a directive to declare this. 4030a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline"); 404a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty()) 405f9f93e4388962b678fd59b7af5212d4cc0d38be2Chris Lattner if (MCSection *S = MAI->getNonexecutableStackSection(OutContext)) 406f9f93e4388962b678fd59b7af5212d4cc0d38be2Chris Lattner OutStreamer.SwitchSection(S); 407bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner 408bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner // Allow the target to emit any magic that it wants at the end of the file, 409bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner // after everything else has gone out. 410bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner EmitEndOfAsmFile(M); 411bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner 412a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner delete Mang; Mang = 0; 4130de1fc4f416b3e94749ca84cdaede55b040a8b60Chris Lattner DW = 0; MMI = 0; 4142b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 4152b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner OutStreamer.Finish(); 416a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner return false; 417a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 418a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 41925045bdcda822d63674e2df7e34016536c5d3fa7Chris Lattnervoid AsmPrinter::SetupMachineFunction(MachineFunction &MF) { 420b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner this->MF = &MF; 421412c3a5bc9e70fe8579551216786e70d323a3dd5Chris Lattner // Get the function symbol. 422d1947ed2f824d2e9f4923fb6efc2aec4a6e3e96dChris Lattner CurrentFnSym = GetGlobalValueSymbol(MF.getFunction()); 423b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene 42425d812bd7d1f58f2ba1b598b1425a2e146e27381Chris Lattner if (VerboseAsm) 425b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene LI = &getAnalysis<MachineLoopInfo>(); 426a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 427a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 4281606e8e4cd937e6de6681f686c266cf61722d972Evan Chengnamespace { 4291606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // SectionCPs - Keep track the alignment, constpool entries per Section. 4301606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng struct SectionCPs { 431a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner const MCSection *S; 4321606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment; 4331606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SmallVector<unsigned, 4> CPEs; 434cabdd7425d30f7eb659ecb0cc5efbc4052dd78a8Douglas Gregor SectionCPs(const MCSection *s, unsigned a) : S(s), Alignment(a) {} 4351606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng }; 4361606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng} 4371606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 4383b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// EmitConstantPool - Print to the current output stream assembly 4393b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// representations of the constants in the constant pool MCP. This is 4403b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// used to print out constants which have been "spilled to memory" by 4413b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// the code generator. 4423b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// 443b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattnervoid AsmPrinter::EmitConstantPool(const MachineConstantPool *MCP) { 444fa77d43ba1d91ed39f46e11caeb28dcabae9e193Chris Lattner const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); 4453b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner if (CP.empty()) return; 4462d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 447088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // Calculate sections for constant pool entries. We collect entries to go into 448088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // the same section together to reduce amount of section switch statements. 4491606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SmallVector<SectionCPs, 4> CPSections; 4502d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng for (unsigned i = 0, e = CP.size(); i != e; ++i) { 451298414ec1891ce8d3a1b69e6019ad8765c8e69dcChris Lattner const MachineConstantPoolEntry &CPE = CP[i]; 4521606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Align = CPE.getAlignment(); 4535c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner 4545c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner SectionKind Kind; 4555c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner switch (CPE.getRelocationInfo()) { 4565c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner default: llvm_unreachable("Unknown section kind"); 4572798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 2: Kind = SectionKind::getReadOnlyWithRel(); break; 4584c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner case 1: 4592798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner Kind = SectionKind::getReadOnlyWithRelLocal(); 4604c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner break; 4615c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner case 0: 4624c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { 4632798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 4: Kind = SectionKind::getMergeableConst4(); break; 4642798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 8: Kind = SectionKind::getMergeableConst8(); break; 4652798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 16: Kind = SectionKind::getMergeableConst16();break; 4662798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner default: Kind = SectionKind::getMergeableConst(); break; 4674c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner } 4685c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner } 4695c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner 47083d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner const MCSection *S = getObjFileLowering().getSectionForConstant(Kind); 471298414ec1891ce8d3a1b69e6019ad8765c8e69dcChris Lattner 4721606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // The number of sections are small, just do a linear search from the 4731606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // last section to the first. 4741606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng bool Found = false; 4751606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned SecIdx = CPSections.size(); 4761606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng while (SecIdx != 0) { 4771606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (CPSections[--SecIdx].S == S) { 4781606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Found = true; 4791606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng break; 4801606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4811606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4821606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (!Found) { 4831606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SecIdx = CPSections.size(); 4841606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections.push_back(SectionCPs(S, Align)); 4851606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 4861606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 4871606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (Align > CPSections[SecIdx].Alignment) 4881606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections[SecIdx].Alignment = Align; 4891606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections[SecIdx].CPEs.push_back(i); 4902d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng } 4912d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 492088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // Now print stuff into the calculated sections. 4931606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng for (unsigned i = 0, e = CPSections.size(); i != e; ++i) { 4946c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(CPSections[i].S); 4951606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitAlignment(Log2_32(CPSections[i].Alignment)); 4962d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 4971606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Offset = 0; 4981606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) { 4991606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned CPI = CPSections[i].CPEs[j]; 5001606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng MachineConstantPoolEntry CPE = CP[CPI]; 5011606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 5021606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // Emit inter-object padding for alignment. 5031606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned AlignMask = CPE.getAlignment() - 1; 5041606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned NewOffset = (Offset + AlignMask) & ~AlignMask; 505aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner OutStreamer.EmitFill(NewOffset - Offset, 0/*fillval*/, 0/*addrspace*/); 5061606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 5071606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng const Type *Ty = CPE.getType(); 508777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands Offset = NewOffset + TM.getTargetData()->getTypeAllocSize(Ty); 5092d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 5103924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner // Emit the label with a comment on it. 5111606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (VerboseAsm) { 5123924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.GetCommentOS() << "constant pool "; 5133924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner WriteTypeSymbolic(OutStreamer.GetCommentOS(), CPE.getType(), 5143924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner MF->getFunction()->getParent()); 5153924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.GetCommentOS() << '\n'; 5161606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 5173924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitLabel(GetCPISymbol(CPI)); 5183924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 5191606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (CPE.isMachineConstantPoolEntry()) 5201606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitMachineConstantPoolValue(CPE.Val.MachineCPVal); 521088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov else 5221606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitGlobalConstant(CPE.Val.ConstVal); 5233029f920519e0871a5aad5d7c592281093953733Chris Lattner } 5243b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner } 5253b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner} 5263b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner 52737efe6764568a3829fee26aba532283131d1a104Nate Begeman/// EmitJumpTableInfo - Print assembly representations of the jump tables used 52837efe6764568a3829fee26aba532283131d1a104Nate Begeman/// by the current function to the current output stream. 52937efe6764568a3829fee26aba532283131d1a104Nate Begeman/// 53044e87255e9b7a9d8ecb558690db1181882c08045Chris Lattnervoid AsmPrinter::EmitJumpTableInfo(MachineFunction &MF) { 53144e87255e9b7a9d8ecb558690db1181882c08045Chris Lattner MachineJumpTableInfo *MJTI = MF.getJumpTableInfo(); 53244e87255e9b7a9d8ecb558690db1181882c08045Chris Lattner if (MJTI == 0) return; 53337efe6764568a3829fee26aba532283131d1a104Nate Begeman const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 53437efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.empty()) return; 5359de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 5362f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman // Pick the directive to use to print the jump table entries, and switch to 5372f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman // the appropriate section. 538e87f52d722d4184becb2ecaf4500dd01d176bfc2Anton Korobeynikov const Function *F = MF.getFunction(); 539b13bafe5c12dd908b55c559c93adaeb1627ed096Evan Cheng bool JTInDiffSection = false; 540f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner if (// In PIC mode, we need to emit the jump table to the same section as the 541f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // function body itself, otherwise the label differences won't make sense. 542f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // FIXME: Need a better predicate for this: what about custom entries? 543f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 || 544f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // We should also do if the section name is NULL or function is declared 545f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // in discardable section 546f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // FIXME: this isn't the right predicate, should be based on the MCSection 547f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // for the function. 548f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner F->isWeakForLinker()) { 5496c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, 5506c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner TM)); 5512f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } else { 55283d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner // Otherwise, drop it in the readonly section. 55383d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner const MCSection *ReadOnlySection = 5542798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly()); 5556c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(ReadOnlySection); 556b13bafe5c12dd908b55c559c93adaeb1627ed096Evan Cheng JTInDiffSection = true; 5572f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } 558071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 559071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner EmitAlignment(Log2_32(MJTI->getEntryAlignment(*TM.getTargetData()))); 5600c4e6789da4dba6c7b0010886776b24dec3f3bb8Chris Lattner 5613b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) { 5623b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; 56307371882208f913d18a7f2a47373eaee7138416bChris Lattner 56407371882208f913d18a7f2a47373eaee7138416bChris Lattner // If this jump table was deleted, ignore it. 56507371882208f913d18a7f2a47373eaee7138416bChris Lattner if (JTBBs.empty()) continue; 56652a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 567e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner // For the EK_LabelDifference32 entry, if the target supports .set, emit a 568e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner // .set directive for each unique entry. This reduces the number of 569e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner // relocations the assembler will generate for the jump table. 570e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 && 571cee63322eaccc2f1067bdf5eab506e440f867da1Chris Lattner MAI->hasSetDirective()) { 5723b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets; 5733b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const TargetLowering *TLI = TM.getTargetLowering(); 5743b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(&MF, JTI, 5753b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner OutContext); 5763b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { 5773b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const MachineBasicBlock *MBB = JTBBs[ii]; 5783b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner if (!EmittedSets.insert(MBB)) continue; 5793b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner 580c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner // .set LJTSet, LBB32-base 581c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner const MCExpr *LHS = 582c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner MCSymbolRefExpr::Create(MBB->getSymbol(OutContext), OutContext); 583c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner OutStreamer.EmitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()), 584c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner MCBinaryExpr::CreateSub(LHS, Base, OutContext)); 5853b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner } 5863b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner } 58752a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 5887c30191393c99c9ba804f1a01942a9e130c53904Chris Lattner // On some targets (e.g. Darwin) we want to emit two consequtive labels 589393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // before each jump table. The first label is never referenced, but tells 590393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // the assembler and linker the extents of the jump table object. The 591393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // second label is actually referenced by the code. 5923924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner if (JTInDiffSection && MAI->getLinkerPrivateGlobalPrefix()[0]) 593beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner // FIXME: This doesn't have to have any specific name, just any randomly 594beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner // named and numbered 'l' label would work. Simplify GetJTISymbol. 5953b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner OutStreamer.EmitLabel(GetJTISymbol(JTI, true)); 5963924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 5973b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner OutStreamer.EmitLabel(GetJTISymbol(JTI)); 5983924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 5996bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) 6003b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner EmitJumpTableEntry(MJTI, JTBBs[ii], JTI); 60137efe6764568a3829fee26aba532283131d1a104Nate Begeman } 60237efe6764568a3829fee26aba532283131d1a104Nate Begeman} 60337efe6764568a3829fee26aba532283131d1a104Nate Begeman 6046bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the 6056bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner/// current stream. 6066bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattnervoid AsmPrinter::EmitJumpTableEntry(const MachineJumpTableInfo *MJTI, 6076bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner const MachineBasicBlock *MBB, 6086bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner unsigned UID) const { 609ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner const MCExpr *Value = 0; 610ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner switch (MJTI->getEntryKind()) { 61185fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner case MachineJumpTableInfo::EK_Custom32: 6126bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner Value = TM.getTargetLowering()->LowerCustomJumpTableEntry(MJTI, MBB, UID, 61385fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner OutContext); 61485fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner break; 615ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner case MachineJumpTableInfo::EK_BlockAddress: 616ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // EK_BlockAddress - Each entry is a plain address of block, e.g.: 617ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .word LBB123 618f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner Value = MCSymbolRefExpr::Create(MBB->getSymbol(OutContext), OutContext); 619ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner break; 620ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner case MachineJumpTableInfo::EK_GPRel32BlockAddress: { 621ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // EK_GPRel32BlockAddress - Each entry is an address of block, encoded 622ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // with a relocation as gp-relative, e.g.: 623ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .gprel32 LBB123 624f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner MCSymbol *MBBSym = MBB->getSymbol(OutContext); 625718fb59801320b8cb22363d115b5fc5ec40dc1f5Chris Lattner OutStreamer.EmitGPRel32Value(MCSymbolRefExpr::Create(MBBSym, OutContext)); 62678f485afb723121eedf4b6907ae6eb53da8af03cChris Lattner return; 6279de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } 62885fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner 629ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner case MachineJumpTableInfo::EK_LabelDifference32: { 630ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // EK_LabelDifference32 - Each entry is the address of the block minus 631ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // the address of the jump table. This is used for PIC jump tables where 632ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // gprel32 is not supported. e.g.: 633ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .word LBB123 - LJTI1_2 634ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // If the .set directive is supported, this is emitted as: 635ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .set L4_5_set_123, LBB123 - LJTI1_2 636ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .word L4_5_set_123 637ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner 638ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // If we have emitted set directives for the jump table entries, print 639ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // them rather than the entries themselves. If we're emitting PIC, then 640ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // emit the table entries as differences between two text section labels. 641cee63322eaccc2f1067bdf5eab506e440f867da1Chris Lattner if (MAI->hasSetDirective()) { 642ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // If we used .set, reference the .set's symbol. 6436bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner Value = MCSymbolRefExpr::Create(GetJTSetSymbol(UID, MBB->getNumber()), 644ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner OutContext); 645ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner break; 646ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner } 6471aca2492526c0a1aa464f2993084f9b30b53c009Chris Lattner // Otherwise, use the difference as the jump table entry. 648f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner Value = MCSymbolRefExpr::Create(MBB->getSymbol(OutContext), OutContext); 6496bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner const MCExpr *JTI = MCSymbolRefExpr::Create(GetJTISymbol(UID), OutContext); 650ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner Value = MCBinaryExpr::CreateSub(Value, JTI, OutContext); 651ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner break; 652ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner } 6539de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } 6541aca2492526c0a1aa464f2993084f9b30b53c009Chris Lattner 655ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner assert(Value && "Unknown entry kind!"); 656ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner 657071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner unsigned EntrySize = MJTI->getEntrySize(*TM.getTargetData()); 658ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner OutStreamer.EmitValue(Value, EntrySize, /*addrspace*/0); 6599de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov} 6609de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 6619de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 662ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// EmitSpecialLLVMGlobal - Check to see if the specified global is a 663ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// special global used by LLVM. If so, emit it and return true, otherwise 664ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// do nothing and return false. 665ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattnerbool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { 66603d7651c3652e1f0cc86e79b26585d86818da9cfDaniel Dunbar if (GV->getName() == "llvm.used") { 6673a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner if (MAI->hasNoDeadStrip()) // No need to emit this at all. 668b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth EmitLLVMUsedList(GV->getInitializer()); 669b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth return true; 670b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth } 671b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth 672401e10c4fbfcdcfade5065093e2ca97f69a1d144Chris Lattner // Ignore debug and non-emitted data. This handles llvm.compiler.used. 673266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner if (GV->getSection() == "llvm.metadata" || 674266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner GV->hasAvailableExternallyLinkage()) 675266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner return true; 6767809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey 6777809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey if (!GV->hasAppendingLinkage()) return false; 6787809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey 6797809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey assert(GV->hasInitializer() && "Not a special LLVM global!"); 680ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 681916d07cdfa89e77118043ec6e14575512ae1bf85Evan Cheng const TargetData *TD = TM.getTargetData(); 682916d07cdfa89e77118043ec6e14575512ae1bf85Evan Cheng unsigned Align = Log2_32(TD->getPointerPrefAlignment()); 683f231c07228deb75b6cd5ae7c9c057bc8303c6998Chris Lattner if (GV->getName() == "llvm.global_ctors") { 6846c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().getStaticCtorSection()); 685ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitAlignment(Align, 0); 686ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitXXStructorList(GV->getInitializer()); 68771eae713153e564ec743c5c4162ff258c255de78Chris Lattner 68871eae713153e564ec743c5c4162ff258c255de78Chris Lattner if (TM.getRelocationModel() == Reloc::Static && 6893a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner MAI->hasStaticCtorDtorReferenceInStaticMode()) { 6903a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner StringRef Sym(".constructors_used"); 6913a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 692a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_Reference); 6933a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner } 694ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner return true; 695ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 696ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 697f231c07228deb75b6cd5ae7c9c057bc8303c6998Chris Lattner if (GV->getName() == "llvm.global_dtors") { 6986c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().getStaticDtorSection()); 699ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitAlignment(Align, 0); 700ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitXXStructorList(GV->getInitializer()); 70171eae713153e564ec743c5c4162ff258c255de78Chris Lattner 70271eae713153e564ec743c5c4162ff258c255de78Chris Lattner if (TM.getRelocationModel() == Reloc::Static && 7033a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner MAI->hasStaticCtorDtorReferenceInStaticMode()) { 7043a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner StringRef Sym(".destructors_used"); 7053a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 706a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_Reference); 7073a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner } 708ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner return true; 709ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 710ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 711ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner return false; 712ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner} 713ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 71433adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each 715d2e51af0358b571367a9f1e5175b87e9dd72edf8Dale Johannesen/// global in the specified llvm.used list for which emitUsedDirectiveFor 716d2e51af0358b571367a9f1e5175b87e9dd72edf8Dale Johannesen/// is true, as being used with this directive. 717cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattnervoid AsmPrinter::EmitLLVMUsedList(Constant *List) { 718a119de86a064414622562cfe32953de7f9b0ee40Dan Gohman // Should be an array of 'i8*'. 719cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner ConstantArray *InitList = dyn_cast<ConstantArray>(List); 720cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner if (InitList == 0) return; 721cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner 722cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 72316fe990e56102a355f1e77aca93bf8c79d7b9eb2Chris Lattner const GlobalValue *GV = 72416fe990e56102a355f1e77aca93bf8c79d7b9eb2Chris Lattner dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts()); 7253a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner if (GV && getObjFileLowering().shouldEmitUsedDirectiveFor(GV, Mang)) 7263a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(GV), 727a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_NoDeadStrip); 728cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner } 729cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner} 730cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner 731ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the 732ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// function pointers, ignoring the init priority. 733ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattnervoid AsmPrinter::EmitXXStructorList(Constant *List) { 734ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner // Should be an array of '{ int, void ()* }' structs. The first value is the 735ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner // init priority, which we ignore. 736ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (!isa<ConstantArray>(List)) return; 737ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner ConstantArray *InitList = cast<ConstantArray>(List); 738ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 739ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ 740ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. 7418de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner 7428de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner if (CS->getOperand(1)->isNullValue()) 7438de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner return; // Found a null terminator, exit printing. 7448de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner // Emit the function pointer. 745ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner EmitGlobalConstant(CS->getOperand(1)); 746ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 747ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner} 7483b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner 749f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey//===--------------------------------------------------------------------===// 750f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey// Emission and print routines 751f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey// 752f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 753f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt8 - Emit a byte directive and value. 754f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 755f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt8(int Value) const { 7565eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 1, 0/*addrspace*/); 757f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 758f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 759f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt16 - Emit a short directive and value. 760f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 761f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt16(int Value) const { 7625eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 2, 0/*addrspace*/); 763f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 764f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 765f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt32 - Emit a long directive and value. 766f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 767f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt32(int Value) const { 7685eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 4, 0/*addrspace*/); 769f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 770f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 771f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt64 - Emit a long long directive and value. 772f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 773f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt64(uint64_t Value) const { 7745eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 8, 0/*addrspace*/); 775f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 776f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 777f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey//===----------------------------------------------------------------------===// 778f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 7793a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// EmitAlignment - Emit an alignment directive to the specified power of 7803a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// two boundary. For example, if you pass in 3 here, you will get an 8 7813a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// byte alignment. If a global value is specified, and if that global has 7823a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// an explicit alignment requested, it will unconditionally override the 7833a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// alignment request. However, if ForcedAlignBits is specified, this value 7843a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// has final say: the ultimate alignment will be the max of ForcedAlignBits 7853a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// and the alignment computed with NumBits and the global. 7863a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// 7873a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// The algorithm is: 7883a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// Align = NumBits; 7893a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// if (GV && GV->hasalignment) Align = GV->getalignment(); 7903a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// Align = std::max(Align, ForcedAlignBits); 7913a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// 7923a4205367dc845d4cd804b47e061f8281777c9daChris Lattnervoid AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV, 79305548eb174dd694b651de334b73197a62e5071f1Evan Cheng unsigned ForcedAlignBits, 79405548eb174dd694b651de334b73197a62e5071f1Evan Cheng bool UseFillExpr) const { 79500d56b96e599acbc4f895e86e17029ae7c45f142Dale Johannesen if (GV && GV->getAlignment()) 7963a4205367dc845d4cd804b47e061f8281777c9daChris Lattner NumBits = Log2_32(GV->getAlignment()); 7973a4205367dc845d4cd804b47e061f8281777c9daChris Lattner NumBits = std::max(NumBits, ForcedAlignBits); 7983a4205367dc845d4cd804b47e061f8281777c9daChris Lattner 7992a21c6e86101c857d683e7bdefb775654ccab7e3Chris Lattner if (NumBits == 0) return; // No need to emit alignment. 800663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner 801663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner unsigned FillValue = 0; 802dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner if (getCurrentSection()->getKind().isText()) 80333adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner FillValue = MAI->getTextAlignFillValue(); 804663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner 805663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner OutStreamer.EmitValueToAlignment(1 << NumBits, FillValue, 1, 0); 806bfddc2030a7e67b9e0c42276525d6932375ff261Chris Lattner} 807a5bb59f85613e8ce481351803e7388f5ab466e72David Greene 80852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner/// LowerConstant - Lower the specified LLVM Constant to an MCExpr. 80952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner/// 81052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattnerstatic const MCExpr *LowerConstant(const Constant *CV, AsmPrinter &AP) { 81152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner MCContext &Ctx = AP.OutContext; 812fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 81352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (CV->isNullValue() || isa<UndefValue>(CV)) 81452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(0, Ctx); 81552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 81652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) 81752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(CI->getZExtValue(), Ctx); 818fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 81952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) 82052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCSymbolRefExpr::Create(AP.GetGlobalValueSymbol(GV), Ctx); 82152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) 82252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx); 823fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 824fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV); 825fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner if (CE == 0) { 82652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner llvm_unreachable("Unknown constant value to lower!"); 82752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(0, Ctx); 828fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 829fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 830fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner switch (CE->getOpcode()) { 831fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::ZExt: 832fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::SExt: 833fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPTrunc: 834fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPExt: 835fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::UIToFP: 836fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::SIToFP: 837fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPToUI: 838fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::FPToSI: 83952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner default: llvm_unreachable("FIXME: Don't support this constant cast expr"); 840fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::GetElementPtr: { 84152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 84252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Generate a symbolic expression for the byte address 84352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const Constant *PtrVal = CE->getOperand(0); 84452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner SmallVector<Value*, 8> IdxVec(CE->op_begin()+1, CE->op_end()); 84552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner int64_t Offset = TD.getIndexedOffset(PtrVal->getType(), &IdxVec[0], 84652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner IdxVec.size()); 84752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 84852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *Base = LowerConstant(CE->getOperand(0), AP); 849fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner if (Offset == 0) 85052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return Base; 851fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 852fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Truncate/sext the offset to the pointer size. 85352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (TD.getPointerSizeInBits() != 64) { 85452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner int SExtAmount = 64-TD.getPointerSizeInBits(); 855fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Offset = (Offset << SExtAmount) >> SExtAmount; 856a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 857fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 85852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx), 85952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner Ctx); 860fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 86152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 86252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Trunc: 86352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // We emit the value and depend on the assembler to truncate the generated 86452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // expression properly. This is important for differences between 86552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // blockaddress labels. Since the two labels are in the same function, it 86652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // is reasonable to treat their delta as a 32-bit value. 86752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // FALL THROUGH. 868fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::BitCast: 86952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return LowerConstant(CE->getOperand(0), AP); 870fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 871fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::IntToPtr: { 87252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 873fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Handle casts to pointers by changing them into casts to the appropriate 874fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // integer type. This promotes constant folding and simplifies this code. 875fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Constant *Op = CE->getOperand(0); 87652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()), 877fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner false/*ZExt*/); 87852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return LowerConstant(Op, AP); 879fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 880fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 881fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::PtrToInt: { 88252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 883fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Support only foldable casts to/from pointers that can be eliminated by 884fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // changing the pointer to the appropriately sized integer type. 885fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Constant *Op = CE->getOperand(0); 886fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner const Type *Ty = CE->getType(); 88752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 88852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *OpExpr = LowerConstant(Op, AP); 889fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 890fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // We can emit the pointer value into this slot if the slot is an 89152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // integer slot equal to the size of the pointer. 89252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType())) 89352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return OpExpr; 89452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 89552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Otherwise the pointer is smaller than the resultant integer, mask off 89652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // the high bits so we are sure to get a proper truncation if the input is 89752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // a constant expr. 89852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType()); 89952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx); 90052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx); 901fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 902ddc94019916fbe4d3fff915e6002c39c63488a44Chris Lattner 903fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Add: 904fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Sub: 905fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::And: 906fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Or: 90752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Xor: { 90852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *LHS = LowerConstant(CE->getOperand(0), AP); 90952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *RHS = LowerConstant(CE->getOperand(1), AP); 910fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner switch (CE->getOpcode()) { 91152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner default: llvm_unreachable("Unknown binary operator constant cast expr"); 91252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx); 91352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx); 91452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx); 91552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Or: return MCBinaryExpr::CreateOr (LHS, RHS, Ctx); 91652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx); 917a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 91852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner } 919a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 920a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 9211b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner 92291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantArray(const ConstantArray *CA, unsigned AddrSpace, 92391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AsmPrinter &AP) { 92405f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner if (AddrSpace != 0 || !CA->isString()) { 92505f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner // Not a string. Print the values in successive locations 92691093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 92791093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AP.EmitGlobalConstant(CA->getOperand(i), AddrSpace); 92805f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner return; 92900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 93005f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 93105f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner // Otherwise, it can be emitted as .ascii. 93205f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner SmallVector<char, 128> TmpVec; 93305f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner TmpVec.reserve(CA->getNumOperands()); 93405f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 93505f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner TmpVec.push_back(cast<ConstantInt>(CA->getOperand(i))->getZExtValue()); 93605f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 93705f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner AP.OutStreamer.EmitBytes(StringRef(TmpVec.data(), TmpVec.size()), AddrSpace); 93800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 93900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 94091093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantVector(const ConstantVector *CV, 94191093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 942bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) 94391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AP.EmitGlobalConstant(CV->getOperand(i), AddrSpace); 94400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 94500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 94691093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantStruct(const ConstantStruct *CS, 94791093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 94800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Print the fields in successive locations. Pad to align if needed! 94991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner const TargetData *TD = AP.TM.getTargetData(); 95091093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned Size = TD->getTypeAllocSize(CS->getType()); 9512dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const StructLayout *Layout = TD->getStructLayout(CS->getType()); 95291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner uint64_t SizeSoFar = 0; 95391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) { 954bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner const Constant *Field = CS->getOperand(i); 95500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 95600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Check if padding is needed and insert one or more 0s. 957bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner uint64_t FieldSize = TD->getTypeAllocSize(Field->getType()); 9582dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1)) 9592dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner - Layout->getElementOffset(i)) - FieldSize; 9602dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner SizeSoFar += FieldSize + PadSize; 96100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 96200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Now print the actual field value. 963bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner AP.EmitGlobalConstant(Field, AddrSpace); 96400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 96500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Insert padding - this may include padding to increase the size of the 96600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // current field up to the ABI size (if the struct is not packed) as well 96700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // as padding to ensure that the next field starts at the right offset. 9682dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitZeros(PadSize, AddrSpace); 96900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 9702dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner assert(SizeSoFar == Layout->getSizeInBytes() && 97100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman "Layout of constant struct may be incorrect!"); 97200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 97300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 9742dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattnerstatic void EmitGlobalConstantFP(const ConstantFP *CFP, unsigned AddrSpace, 9752dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AsmPrinter &AP) { 97600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // FP Constants are printed as integer constants to avoid losing 9779ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner // precision. 978cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isDoubleTy()) { 9792dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 980d79d9dce47d505369662ae5111dba24f9ccdef68Chris Lattner double Val = CFP->getValueAPF().convertToDouble(); 981d79d9dce47d505369662ae5111dba24f9ccdef68Chris Lattner AP.OutStreamer.GetCommentOS() << "double " << Val << '\n'; 98209ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner } 98309ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner 9842dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 9852dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 98600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 987cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 988cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 989cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isFloatTy()) { 9902dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 9910fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner float Val = CFP->getValueAPF().convertToFloat(); 9920fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner AP.OutStreamer.GetCommentOS() << "float " << Val << '\n'; 993a12e9d751b64767a5c41a718da2a91122d5874c4Dan Gohman } 9942dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 9952dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 4, AddrSpace); 99600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 997cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 998cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 999cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isX86_FP80Ty()) { 100000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // all long double variants are printed as hex 100100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // api needed to prevent premature destruction 100209ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner APInt API = CFP->getValueAPF().bitcastToAPInt(); 100309ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner const uint64_t *p = API.getRawData(); 10042dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 100572b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner // Convert to double so we can print the approximate val as a comment. 100672b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner APFloat DoubleVal = CFP->getValueAPF(); 100772b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner bool ignored; 100872b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 100972b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner &ignored); 10100fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner AP.OutStreamer.GetCommentOS() << "x86_fp80 ~= " 10110fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner << DoubleVal.convertToDouble() << '\n'; 101272b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner } 101372b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner 10142dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.TM.getTargetData()->isBigEndian()) { 10152dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 10162dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 101772b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner } else { 10182dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 10192dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 102000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 10219ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner 10229ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner // Emit the tail padding for the long double. 10232dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 10242dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitZeros(TD.getTypeAllocSize(CFP->getType()) - 10252dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner TD.getTypeStoreSize(CFP->getType()), AddrSpace); 102600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 1027cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 1028cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 102909ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner assert(CFP->getType()->isPPC_FP128Ty() && 103009ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner "Floating point constant type not handled"); 103109ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner // All long double variants are printed as hex api needed to prevent 103209ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner // premature destruction. 103309ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner APInt API = CFP->getValueAPF().bitcastToAPInt(); 103409ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner const uint64_t *p = API.getRawData(); 10352dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.TM.getTargetData()->isBigEndian()) { 10362dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 10372dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 10389ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner } else { 10392dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 10402dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 104109ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner } 104200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 104300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 10442dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattnerstatic void EmitGlobalConstantLargeInt(const ConstantInt *CI, 10452dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 10462dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const TargetData *TD = AP.TM.getTargetData(); 104700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman unsigned BitWidth = CI->getBitWidth(); 104838c2b0a99c6a3f5cdf6ef5a46e4a6826b30acbfbChris Lattner assert((BitWidth & 63) == 0 && "only support multiples of 64-bits"); 104900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 105000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // We don't expect assemblers to support integer data directives 105100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // for more than 64 bits, so we emit the data in at most 64-bit 105200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // quantities at a time. 105300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman const uint64_t *RawData = CI->getValue().getRawData(); 105400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { 10552dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = TD->isBigEndian() ? RawData[e - i - 1] : RawData[i]; 10562dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 105700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 105800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 105900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 106025045bdcda822d63674e2df7e34016536c5d3fa7Chris Lattner/// EmitGlobalConstant - Print a general LLVM constant to the .s file. 1061c8d7bc850ddf5a5df503a173b0bc0f8c03ffec96Sanjiv Guptavoid AsmPrinter::EmitGlobalConstant(const Constant *CV, unsigned AddrSpace) { 1062043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV)) { 10632dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 10646449abfbc86310edbbe0b5ffb3fad5c14301307fChris Lattner return OutStreamer.EmitZeros(Size, AddrSpace); 10652dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 10662dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner 10672dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 10682dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner unsigned Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 10692dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner switch (Size) { 10702dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 1: 10712dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 2: 10722dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 4: 10732dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 8: 10740fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) 10750fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << format("0x%llx\n", CI->getZExtValue()); 10762dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner OutStreamer.EmitIntValue(CI->getZExtValue(), Size, AddrSpace); 10772dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return; 10782dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner default: 10792dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner EmitGlobalConstantLargeInt(CI, AddrSpace, *this); 10802dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return; 10812dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 10822dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 10833cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 108491093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) 108591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantArray(CVA, AddrSpace, *this); 10863cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 108791093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) 108891093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantStruct(CVS, AddrSpace, *this); 10893cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 109091093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) 10912dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return EmitGlobalConstantFP(CFP, AddrSpace, *this); 10923cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 109391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantVector *V = dyn_cast<ConstantVector>(CV)) 109491093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantVector(V, AddrSpace, *this); 10951b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner 1096b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner if (isa<ConstantPointerNull>(CV)) { 1097b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner unsigned Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 1098b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner OutStreamer.EmitIntValue(0, Size, AddrSpace); 1099b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner return; 1100b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner } 1101b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner 110252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it 110352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // thread the streamer with EmitValue. 110452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner OutStreamer.EmitValue(LowerConstant(CV, *this), 110552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner TM.getTargetData()->getTypeAllocSize(CV->getType()), 110652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner AddrSpace); 11071b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner} 11080264d1a4777370009176157b76d116b3195e3767Chris Lattner 1109fad86b003a839cef40ec8ce8408322f4913368caChris Lattnervoid AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { 1110d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // Target doesn't support this yet! 1111c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Target does not support EmitMachineConstantPoolValue"); 1112d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 1113d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 11143ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// PrintSpecial - Print information related to the specified machine instr 11153ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// that is independent of the operand, and may be independent of the instr 11163ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// itself. This can be useful for portably encoding the comment character 11173ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// or other bits of target-specific knowledge into the asmstrings. The 11183ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// syntax used is ${:comment}. Targets can override this to add support 11193ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// for their own strange codes. 11203e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattnervoid AsmPrinter::PrintSpecial(const MachineInstr *MI, const char *Code) const { 1121bae02cfd46c569bb571a234544fb1bbe19c43b59Chris Lattner if (!strcmp(Code, "private")) { 112233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getPrivateGlobalPrefix(); 1123bae02cfd46c569bb571a234544fb1bbe19c43b59Chris Lattner } else if (!strcmp(Code, "comment")) { 1124f1c0ae9de5365a578fbdfebe4625fb281b0be592Evan Cheng if (VerboseAsm) 112533adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString(); 11263ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } else if (!strcmp(Code, "uid")) { 1127b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner // Comparing the address of MI isn't sufficient, because machineinstrs may 1128b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner // be allocated to the same address across functions. 1129b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner const Function *ThisF = MI->getParent()->getParent()->getFunction(); 1130b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner 1131bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson // If this is a new LastFn instruction, bump the counter. 1132bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson if (LastMI != MI || LastFn != ThisF) { 1133b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner ++Counter; 1134b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner LastMI = MI; 1135bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson LastFn = ThisF; 1136b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner } 11373ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner O << Counter; 11383ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } else { 11397d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin std::string msg; 11407d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin raw_string_ostream Msg(msg); 11417d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin Msg << "Unknown special formatter '" << Code 1142e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "' for machine instr: " << *MI; 11437d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error(Msg.str()); 11443ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } 11453ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner} 11463ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner 1147cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis/// processDebugLoc - Processes the debug information of each machine 1148cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis/// instruction's DebugLoc. 1149af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patelvoid AsmPrinter::processDebugLoc(const MachineInstr *MI, 1150af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patel bool BeforePrintingInsn) { 115153bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (!MAI || !DW || !MAI->doesSupportDebugInformation() 115253bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel || !DW->ShouldEmitDwarfDebug()) 1153d250329291dd9fe0d5f0e72e6cf1e287558a7cbaChris Lattner return; 1154b0fdedb3fd123a47e7deca75d1e6f7d64218b07aDevang Patel DebugLoc DL = MI->getDebugLoc(); 115553bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (DL.isUnknown()) 115653bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel return; 11576b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DILocation CurDLT = MF->getDILocation(DL); 11586b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel if (CurDLT.getScope().isNull()) 115953bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel return; 116053bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel 1161043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner if (!BeforePrintingInsn) { 116253bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel // After printing instruction 116353bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel DW->EndScope(MI); 1164043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner } else if (CurDLT.getNode() != PrevDLT) { 1165043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner unsigned L = DW->RecordSourceLine(CurDLT.getLineNumber(), 1166043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner CurDLT.getColumnNumber(), 1167043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner CurDLT.getScope().getNode()); 1168043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner printLabel(L); 1169043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner O << '\n'; 1170043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner DW->BeginScope(MI, L); 1171043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner PrevDLT = CurDLT.getNode(); 1172cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis } 1173cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis} 11743ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner 117553bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel 11760264d1a4777370009176157b76d116b3195e3767Chris Lattner/// printInlineAsm - This method formats and prints the specified machine 11770264d1a4777370009176157b76d116b3195e3767Chris Lattner/// instruction that is an inline asm. 11780264d1a4777370009176157b76d116b3195e3767Chris Lattnervoid AsmPrinter::printInlineAsm(const MachineInstr *MI) const { 1179f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner unsigned NumOperands = MI->getNumOperands(); 1180f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner 1181f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner // Count the number of register definitions. 1182f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner unsigned NumDefs = 0; 1183d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef(); 118467942f5dc30be1810f983aba8c94c49ca44e8634Chris Lattner ++NumDefs) 1185f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner assert(NumDefs != NumOperands-1 && "No asm string?"); 1186f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner 1187d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman assert(MI->getOperand(NumDefs).isSymbol() && "No asm string?"); 11886609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 11896609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Disassemble the AsmStr, printing out the literal pieces, the operands, etc. 1190f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner const char *AsmStr = MI->getOperand(NumDefs).getSymbolName(); 11916609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 119240c57860dad429d3c938ed5f918c2c66f3b5fa72Dan Gohman O << '\t'; 119340c57860dad429d3c938ed5f918c2c66f3b5fa72Dan Gohman 1194ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // If this asmstr is empty, just print the #APP/#NOAPP markers. 1195ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // These are useful to see where empty asm's wound up. 1196f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner if (AsmStr[0] == 0) { 119733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmStart() << "\n\t"; 119833adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmEnd() << '\n'; 1199f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner return; 1200f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner } 1201f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner 120233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmStart() << "\n\t"; 1203f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner 1204eb9a42c90bf7e21ad8544315a65f86b668cc0277Bill Wendling // The variant of the current asmprinter. 120533adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner int AsmPrinterVariant = MAI->getAssemblerDialect(); 1206eb9a42c90bf7e21ad8544315a65f86b668cc0277Bill Wendling 12076609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner int CurVariant = -1; // The number of the {.|.|.} region we are in. 12086609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *LastEmitted = AsmStr; // One past the last character emitted. 12092cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 12106609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner while (*LastEmitted) { 12116609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner switch (*LastEmitted) { 12126609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner default: { 12136609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Not a special case, emit the string section literally. 12146609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *LiteralEnd = LastEmitted+1; 12156609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && 12161c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') 12176609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LiteralEnd; 12186609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 12196609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner O.write(LastEmitted, LiteralEnd-LastEmitted); 12206609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner LastEmitted = LiteralEnd; 12216609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 12226609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12231c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner case '\n': 12241c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner ++LastEmitted; // Consume newline character. 1225d19a53ba1d4629f69821f37ca824c65e6df8e8f9Dan Gohman O << '\n'; // Indent code with newline. 12261c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner break; 12276609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner case '$': { 12286609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '$' character. 1229faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner bool Done = true; 1230faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner 1231faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner // Handle escapes. 1232faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner switch (*LastEmitted) { 1233faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner default: Done = false; break; 1234faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '$': // $$ -> $ 12356609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 12366609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner O << '$'; 12376609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume second '$' character. 12386609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 1239faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '(': // $( -> same as GCC's { character. 1240faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // Consume '(' character. 1241faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner if (CurVariant != -1) { 12427d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Nested variants found in inline asm string: '" 12437d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 1244faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner } 1245faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner CurVariant = 0; // We're in the first variant now. 1246faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 1247faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '|': 1248faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // consume '|' character. 12498b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen if (CurVariant == -1) 12508b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen O << '|'; // this is gcc's behavior for | outside a variant 12518b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen else 12528b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen ++CurVariant; // We're in the next variant. 1253faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 1254faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case ')': // $) -> same as GCC's } char. 1255faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // consume ')' character. 12568b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen if (CurVariant == -1) 12578b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen O << '}'; // this is gcc's behavior for } outside a variant 12588b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen else 12598b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen CurVariant = -1; 1260faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 12616609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1262faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner if (Done) break; 12636609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 12646609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner bool HasCurlyBraces = false; 12656609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (*LastEmitted == '{') { // ${variable} 12666609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '{' character. 12676609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner HasCurlyBraces = true; 12686609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 12703e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // If we have ${:foo}, then this is not a real operand reference, it is a 12713e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // "magic" string reference, just like in .td files. Arrange to call 12723e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // PrintSpecial. 12733e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner if (HasCurlyBraces && *LastEmitted == ':') { 12743e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner ++LastEmitted; 12753e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner const char *StrStart = LastEmitted; 12763e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner const char *StrEnd = strchr(StrStart, '}'); 12773e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner if (StrEnd == 0) { 12787d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Unterminated ${:foo} operand in inline asm string: '" 12797d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 12803e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner } 12813e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner 12823e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner std::string Val(StrStart, StrEnd); 12833e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner PrintSpecial(MI, Val.c_str()); 12843e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner LastEmitted = StrEnd+1; 12853e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner break; 12863e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner } 12873e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner 12886609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *IDStart = LastEmitted; 12896609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner char *IDEnd; 1290fad2912522a4c97128d8afcc2f40ca0e39287ddbChris Lattner errno = 0; 12916609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner long Val = strtol(IDStart, &IDEnd, 10); // We only accept numbers for IDs. 12926609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (!isdigit(*IDStart) || (Val == 0 && errno == EINVAL)) { 12937d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad $ operand number in inline asm string: '" 12947d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 12956609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 12966609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner LastEmitted = IDEnd; 12976609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1298a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner char Modifier[2] = { 0, 0 }; 1299a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 13006609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (HasCurlyBraces) { 1301a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner // If we have curly braces, check for a modifier character. This 1302a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm. 1303a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner if (*LastEmitted == ':') { 1304a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner ++LastEmitted; // Consume ':' character. 1305a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner if (*LastEmitted == 0) { 13067d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad ${:} expression in inline asm string: '" 13077d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 1308a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner } 1309a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 1310a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner Modifier[0] = *LastEmitted; 1311a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner ++LastEmitted; // Consume modifier character. 1312a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner } 1313a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 13146609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (*LastEmitted != '}') { 13157d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad ${} expression in inline asm string: '" 13167d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 13176609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13186609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '}' character. 13196609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13206609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 13216609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if ((unsigned)Val >= NumOperands-1) { 13227d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Invalid $ operand number in inline asm string: '" 13237d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 13246609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13256609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1326c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Okay, we finally have a value number. Ask the target to print this 13276609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // operand! 1328c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) { 1329c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned OpNo = 1; 1330fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1331fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner bool Error = false; 1332fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1333c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan to find the machine operand number for the operand. 1334daf6bc6347b4785102611bdf21c512e8a7678cceChris Lattner for (; Val; --Val) { 1335fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner if (OpNo >= MI->getNumOperands()) break; 13369e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned OpFlags = MI->getOperand(OpNo).getImm(); 1337697cbbfb00c318f98d6eb51945f077e2bfe8781eEvan Cheng OpNo += InlineAsm::getNumOperandRegisters(OpFlags) + 1; 1338daf6bc6347b4785102611bdf21c512e8a7678cceChris Lattner } 1339fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1340fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner if (OpNo >= MI->getNumOperands()) { 1341fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner Error = true; 1342dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner } else { 13439e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned OpFlags = MI->getOperand(OpNo).getImm(); 1344fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner ++OpNo; // Skip over the ID number. 1345fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 134610b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner if (Modifier[0] == 'l') // labels are target independent 1347f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner O << *MI->getOperand(OpNo).getMBB()->getSymbol(OutContext); 1348eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen else { 1349eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen AsmPrinter *AP = const_cast<AsmPrinter*>(this); 135086b49f8e2de796cb46c7c8b6a4c4900533fd53f4Dale Johannesen if ((OpFlags & 7) == 4) { 1351eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Error = AP->PrintAsmMemoryOperand(MI, OpNo, AsmPrinterVariant, 1352eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Modifier[0] ? Modifier : 0); 1353eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } else { 1354eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Error = AP->PrintAsmOperand(MI, OpNo, AsmPrinterVariant, 1355eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Modifier[0] ? Modifier : 0); 1356eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } 1357fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner } 1358dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner } 1359dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner if (Error) { 13607d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin std::string msg; 13617d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin raw_string_ostream Msg(msg); 136210b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner Msg << "Invalid operand found in inline asm: '" << AsmStr << "'\n"; 13637d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin MI->print(Msg); 13647d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error(Msg.str()); 13656609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1366c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 13676609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 13686609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13706609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1371c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << "\n\t" << MAI->getCommentString() << MAI->getInlineAsmEnd(); 13726609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner} 13736609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1374da47e6e0d003c873da960361549e57ee4617c301Evan Cheng/// printImplicitDef - This method prints the specified machine instruction 1375da47e6e0d003c873da960361549e57ee4617c301Evan Cheng/// that is an implicit def. 1376da47e6e0d003c873da960361549e57ee4617c301Evan Chengvoid AsmPrinter::printImplicitDef(const MachineInstr *MI) const { 1377c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner if (!VerboseAsm) return; 1378c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O.PadToColumn(MAI->getCommentColumn()); 1379c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << MAI->getCommentString() << " implicit-def: " 1380f806c23a9a297e0b6d19d82ed23c6c5921d6ecd9Chris Lattner << TRI->getName(MI->getOperand(0).getReg()); 1381da47e6e0d003c873da960361549e57ee4617c301Evan Cheng} 1382da47e6e0d003c873da960361549e57ee4617c301Evan Cheng 1383ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesenvoid AsmPrinter::printKill(const MachineInstr *MI) const { 1384ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen if (!VerboseAsm) return; 1385ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O.PadToColumn(MAI->getCommentColumn()); 1386ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O << MAI->getCommentString() << " kill:"; 1387ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen for (unsigned n = 0, e = MI->getNumOperands(); n != e; ++n) { 1388ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen const MachineOperand &op = MI->getOperand(n); 1389ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen assert(op.isReg() && "KILL instruction must have only register operands"); 1390ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O << ' ' << TRI->getName(op.getReg()) << (op.isDef() ? "<def>" : "<kill>"); 1391ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen } 1392ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen} 1393ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen 13941ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey/// printLabel - This method prints a local label used by debug and 13951ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey/// exception handling tables. 13961ee29257428960fede862fcfdbe80d5d007927e9Jim Laskeyvoid AsmPrinter::printLabel(const MachineInstr *MI) const { 1397528bc028774513ee76125f85ceb8f704f5901cc8Dan Gohman printLabel(MI->getOperand(0).getImm()); 13981ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey} 13991ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey 14001b08bbca5592351a940bcd164bdec724ee954326Evan Chengvoid AsmPrinter::printLabel(unsigned Id) const { 1401c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << MAI->getPrivateGlobalPrefix() << "label" << Id << ':'; 14021b08bbca5592351a940bcd164bdec724ee954326Evan Cheng} 14031b08bbca5592351a940bcd164bdec724ee954326Evan Cheng 14046609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner/// PrintAsmOperand - Print the specified operand of MI, an INLINEASM 14056609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner/// instruction, using the specified assembler variant. Targets should 1406cf0b76649be4eea33aba783d4154ea338b7cbbc2Dale Johannesen/// override this to format as appropriate. 14076609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattnerbool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 1408a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner unsigned AsmVariant, const char *ExtraCode) { 14096609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Target doesn't support this yet! 14106609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner return true; 14110264d1a4777370009176157b76d116b3195e3767Chris Lattner} 1412dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner 1413dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattnerbool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 1414dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner unsigned AsmVariant, 1415dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner const char *ExtraCode) { 1416dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner // Target doesn't support this yet! 1417dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner return true; 1418dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner} 141937efe6764568a3829fee26aba532283131d1a104Nate Begeman 142029cbade25aa094ca9a149a96a8614cf6f3247480Dan GohmanMCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA, 142129cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman const char *Suffix) const { 142229cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman return GetBlockAddressSymbol(BA->getFunction(), BA->getBasicBlock(), Suffix); 14238c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman} 14248c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 14258c2b52552c90f39e4b2fed43e309e599e742b6acDan GohmanMCSymbol *AsmPrinter::GetBlockAddressSymbol(const Function *F, 142629cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman const BasicBlock *BB, 142729cbade25aa094ca9a149a96a8614cf6f3247480Dan Gohman const char *Suffix) const { 14288c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman assert(BB->hasName() && 14298c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman "Address of anonymous basic block not supported yet!"); 14308c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 1431568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // This code must use the function name itself, and not the function number, 1432568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // since it must be possible to generate the label name from within other 1433568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // functions. 14342f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner SmallString<60> FnName; 14352f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mang->getNameWithPrefix(FnName, F, false); 14368c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 14372f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner // FIXME: THIS IS BROKEN IF THE LLVM BASIC BLOCK DOESN'T HAVE A NAME! 14384813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner SmallString<60> NameResult; 14392f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mang->getNameWithPrefix(NameResult, 14402f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner StringRef("BA") + Twine((unsigned)FnName.size()) + 14412f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner "_" + FnName.str() + "_" + BB->getName() + Suffix, 14422f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mangler::Private); 14434813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner 14444813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner return OutContext.GetOrCreateSymbol(NameResult.str()); 14458c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman} 14468c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 14473924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner/// GetCPISymbol - Return the symbol for the specified constant pool entry. 14483924868a957d5a6d468b61741cbb7db77324d1f6Chris LattnerMCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { 14493924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner SmallString<60> Name; 14503924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "CPI" 14513924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner << getFunctionNumber() << '_' << CPID; 14523924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner return OutContext.GetOrCreateSymbol(Name.str()); 14533924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner} 14543924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 14553924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner/// GetJTISymbol - Return the symbol for the specified jump table entry. 14563924868a957d5a6d468b61741cbb7db77324d1f6Chris LattnerMCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { 1457589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate); 14587cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner} 14597cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner 1460798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner/// GetJTSetSymbol - Return the symbol for the specified jump table .set 1461798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner/// FIXME: privatize to AsmPrinter. 1462798d1256595dcc0f5d4423572f856d239f7de0e6Chris LattnerMCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const { 1463798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner SmallString<60> Name; 1464798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() 1465798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner << getFunctionNumber() << '_' << UID << "_set_" << MBBID; 1466798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner return OutContext.GetOrCreateSymbol(Name.str()); 1467798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner} 1468798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner 14696b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// GetGlobalValueSymbol - Return the MCSymbol for the specified global 14706b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// value. 14716b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris LattnerMCSymbol *AsmPrinter::GetGlobalValueSymbol(const GlobalValue *GV) const { 14726b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner SmallString<60> NameStr; 14736b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner Mang->getNameWithPrefix(NameStr, GV, false); 14746b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 14756b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner} 14766b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner 14777a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner/// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with 1478d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner/// global value name as its base, with the specified suffix, and where the 14797a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner/// symbol is forced to have private linkage if ForcePrivate is true. 14807a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris LattnerMCSymbol *AsmPrinter::GetSymbolWithGlobalValueBase(const GlobalValue *GV, 14817a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner StringRef Suffix, 14827a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner bool ForcePrivate) const { 1483d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner SmallString<60> NameStr; 14847a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner Mang->getNameWithPrefix(NameStr, GV, ForcePrivate); 1485d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner NameStr.append(Suffix.begin(), Suffix.end()); 1486d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 1487d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner} 1488d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner 14896b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// GetExternalSymbolSymbol - Return the MCSymbol for the specified 14906b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// ExternalSymbol. 14916b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris LattnerMCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const { 14926b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner SmallString<60> NameStr; 14936b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner Mang->getNameWithPrefix(NameStr, Sym); 14946b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 14956b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner} 14966b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner 14977cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner 1498523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1499523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// PrintParentLoopComment - Print comments about parent loops of this one. 1500523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1501523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner unsigned FunctionNumber) { 1502523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop == 0) return; 1503523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber); 1504523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent(Loop->getLoopDepth()*2) 1505523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << "Parent Loop BB" << FunctionNumber << "_" 1506523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << Loop->getHeader()->getNumber() 1507523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << " Depth=" << Loop->getLoopDepth() << '\n'; 1508523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1509523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1510523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1511523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// PrintChildLoopComment - Print comments about child loops within 1512523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// the loop for this basic block, with nesting. 1513523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1514523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner unsigned FunctionNumber) { 1515523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Add child loop information 1516523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner for (MachineLoop::iterator CL = Loop->begin(), E = Loop->end();CL != E; ++CL){ 1517523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent((*CL)->getLoopDepth()*2) 1518523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << "Child Loop BB" << FunctionNumber << "_" 1519523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << (*CL)->getHeader()->getNumber() << " Depth " << (*CL)->getLoopDepth() 1520523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << '\n'; 1521523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintChildLoopComment(OS, *CL, FunctionNumber); 1522523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner } 1523523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1524523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1525523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// EmitComments - Pretty-print comments for basic blocks. 1526523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintBasicBlockLoopComments(const MachineBasicBlock &MBB, 1527523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const MachineLoopInfo *LI, 1528523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const AsmPrinter &AP) { 1529523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Add loop depth information 1530523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const MachineLoop *Loop = LI->getLoopFor(&MBB); 1531523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop == 0) return; 1532523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1533523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner MachineBasicBlock *Header = Loop->getHeader(); 1534523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner assert(Header && "No header for loop"); 1535523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1536523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // If this block is not a loop header, just print out what is the loop header 1537523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // and return. 1538523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Header != &MBB) { 1539523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner AP.OutStreamer.AddComment(" in Loop: Header=BB" + 1540523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner Twine(AP.getFunctionNumber())+"_" + 1541523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner Twine(Loop->getHeader()->getNumber())+ 1542523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner " Depth="+Twine(Loop->getLoopDepth())); 1543523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner return; 1544523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner } 1545523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1546523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Otherwise, it is a loop header. Print out information about child and 1547523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // parent loops. 1548523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner raw_ostream &OS = AP.OutStreamer.GetCommentOS(); 1549523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1550523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber()); 1551523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1552523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "=>"; 1553523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent(Loop->getLoopDepth()*2-2); 1554523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1555523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "This "; 1556523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop->empty()) 1557523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "Inner "; 1558523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n'; 1559523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1560523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); 1561523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1562523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1563523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 156470a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// EmitBasicBlockStart - This method prints the label for the specified 156570a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// MachineBasicBlock, an alignment (if present) and a comment describing 156670a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// it if appropriate. 1567662316c997e4eb8c3fdec6999b3e9da03620847aChris Lattnervoid AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock *MBB) const { 1568b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // Emit an alignment directive for this block, if needed. 156970a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner if (unsigned Align = MBB->getAlignment()) 157070a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner EmitAlignment(Log2_32(Align)); 1571fb8075d03f5c87bd57dcc9c5f2304f6b13c55aadEvan Cheng 1572b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // If the block has its address taken, emit a special label to satisfy 1573b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // references to the block. This is done so that we don't need to 1574b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // remember the number of this label, and so that we can make 1575b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // forward references to labels without knowing what their numbers 1576b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // will be. 15778c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman if (MBB->hasAddressTaken()) { 1578213168ba469703a186d060281e587d828878aa75Chris Lattner const BasicBlock *BB = MBB->getBasicBlock(); 15790fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) 15800fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("Address Taken"); 1581213168ba469703a186d060281e587d828878aa75Chris Lattner OutStreamer.EmitLabel(GetBlockAddressSymbol(BB->getParent(), BB)); 15828c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman } 15838c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 1584b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // Print the main label for the block. 1585e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman if (MBB->pred_empty() || MBB->isOnlyReachableByFallthrough()) { 15860fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) { 15873a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner // NOTE: Want this comment at start of line. 1588e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman O << MAI->getCommentString() << " BB#" << MBB->getNumber() << ':'; 15890fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (const BasicBlock *BB = MBB->getBasicBlock()) 15900fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (BB->hasName()) 15910fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("%" + BB->getName()); 1592d8d0aee26a5a759085bfa9114302e507c8685599Chris Lattner 1593523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintBasicBlockLoopComments(*MBB, LI, *this); 15940fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddBlankLine(); 15950fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner } 1596e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman } else { 15970fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) { 15980fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (const BasicBlock *BB = MBB->getBasicBlock()) 15990fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (BB->hasName()) 16000fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("%" + BB->getName()); 1601523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintBasicBlockLoopComments(*MBB, LI, *this); 16020fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner } 1603d8d0aee26a5a759085bfa9114302e507c8685599Chris Lattner 1604f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner OutStreamer.EmitLabel(MBB->getSymbol(OutContext)); 1605e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman } 160637efe6764568a3829fee26aba532283131d1a104Nate Begeman} 160752a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 1608152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattnervoid AsmPrinter::printVisibility(MCSymbol *Sym, unsigned Visibility) const { 1609b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // FIXME: RENAME TO EmitVisibility. 1610152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner MCSymbolAttr Attr = MCSA_Invalid; 1611152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner 1612152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner switch (Visibility) { 1613152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner default: break; 1614152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner case GlobalValue::HiddenVisibility: 1615152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner Attr = MAI->getHiddenVisibilityAttr(); 1616152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner break; 1617152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner case GlobalValue::ProtectedVisibility: 1618152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner Attr = MAI->getProtectedVisibilityAttr(); 1619152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner break; 162053d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner } 1621152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner 1622152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner if (Attr != MCSA_Invalid) 1623152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner OutStreamer.EmitSymbolAttribute(Sym, Attr); 162453d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner} 162553d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner 16267751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikovvoid AsmPrinter::printOffset(int64_t Offset) const { 16277751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov if (Offset > 0) 16287751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov O << '+' << Offset; 16297751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov else if (Offset < 0) 16307751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov O << Offset; 16317751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov} 16327751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov 16335eca075b74d62c621b160aa216b4cd50829a2cc7Gordon HenriksenGCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy *S) { 16345eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (!S->usesMetadata()) 1635c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen return 0; 1636c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 16375eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen gcp_iterator GCPI = GCMetadataPrinters.find(S); 1638c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen if (GCPI != GCMetadataPrinters.end()) 1639c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen return GCPI->second; 1640c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 16415eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen const char *Name = S->getName().c_str(); 1642c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 1643c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen for (GCMetadataPrinterRegistry::iterator 1644c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen I = GCMetadataPrinterRegistry::begin(), 1645c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen E = GCMetadataPrinterRegistry::end(); I != E; ++I) 1646c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen if (strcmp(Name, I->getName()) == 0) { 16475eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCMetadataPrinter *GMP = I->instantiate(); 16485eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GMP->S = S; 16495eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCMetadataPrinters.insert(std::make_pair(S, GMP)); 16505eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen return GMP; 1651c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen } 1652c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 165352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner llvm_report_error("no GCMetadataPrinter registered for GC: " + Twine(Name)); 165452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return 0; 1655c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen} 1656014700c1a8cba203fd21ff129426ba8a426ab244David Greene 1657014700c1a8cba203fd21ff129426ba8a426ab244David Greene/// EmitComments - Pretty-print comments for instructions 16585f51cd057984b89e0dc0812d45d512596a3c6596Chris Lattnervoid AsmPrinter::EmitComments(const MachineInstr &MI) const { 16591924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene if (!VerboseAsm) 16601924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene return; 16615f51cd057984b89e0dc0812d45d512596a3c6596Chris Lattner 16621924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene bool Newline = false; 16631924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene 16641924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene if (!MI.getDebugLoc().isUnknown()) { 16656b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DILocation DLT = MF->getDILocation(MI.getDebugLoc()); 16661924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene 16671924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene // Print source line info. 16681924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene O.PadToColumn(MAI->getCommentColumn()); 16693b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman O << MAI->getCommentString() << ' '; 16706b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DIScope Scope = DLT.getScope(); 16713b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman // Omit the directory, because it's likely to be long and uninteresting. 16723b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman if (!Scope.isNull()) 16733b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman O << Scope.getFilename(); 16743b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman else 16753b9bc04eda3401618b4fa2318f41b4207d72deceDan Gohman O << "<unknown>"; 16766b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel O << ':' << DLT.getLineNumber(); 16776b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel if (DLT.getColumnNumber() != 0) 16786b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel O << ':' << DLT.getColumnNumber(); 16791924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene Newline = true; 16803ac1ab835caacdeebbd0d7b4d69160f283928d21David Greene } 16811924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene 1682ddff941357bd836243ed7004ab88db09490176d8David Greene // Check for spills and reloads 1683ddff941357bd836243ed7004ab88db09490176d8David Greene int FI; 1684ddff941357bd836243ed7004ab88db09490176d8David Greene 1685ddff941357bd836243ed7004ab88db09490176d8David Greene const MachineFrameInfo *FrameInfo = 1686ddff941357bd836243ed7004ab88db09490176d8David Greene MI.getParent()->getParent()->getFrameInfo(); 1687ddff941357bd836243ed7004ab88db09490176d8David Greene 1688ddff941357bd836243ed7004ab88db09490176d8David Greene // We assume a single instruction only has a spill or reload, not 1689ddff941357bd836243ed7004ab88db09490176d8David Greene // both. 1690f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene const MachineMemOperand *MMO; 1691ddff941357bd836243ed7004ab88db09490176d8David Greene if (TM.getInstrInfo()->isLoadFromStackSlotPostFE(&MI, FI)) { 1692ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1693f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene MMO = *MI.memoperands_begin(); 1694ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1695ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1696fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' << MMO->getSize() << "-byte Reload"; 1697ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1698ddff941357bd836243ed7004ab88db09490176d8David Greene } 1699ddff941357bd836243ed7004ab88db09490176d8David Greene } 1700f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene else if (TM.getInstrInfo()->hasLoadFromStackSlot(&MI, MMO, FI)) { 1701ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1702ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1703ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1704fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' 1705fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman << MMO->getSize() << "-byte Folded Reload"; 1706ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1707ddff941357bd836243ed7004ab88db09490176d8David Greene } 1708ddff941357bd836243ed7004ab88db09490176d8David Greene } 1709ddff941357bd836243ed7004ab88db09490176d8David Greene else if (TM.getInstrInfo()->isStoreToStackSlotPostFE(&MI, FI)) { 1710ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1711f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene MMO = *MI.memoperands_begin(); 1712ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1713ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1714fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' << MMO->getSize() << "-byte Spill"; 1715ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1716ddff941357bd836243ed7004ab88db09490176d8David Greene } 1717ddff941357bd836243ed7004ab88db09490176d8David Greene } 1718f7ea2a534ba4151e091e270c5b908167ab4bba4dDavid Greene else if (TM.getInstrInfo()->hasStoreToStackSlot(&MI, MMO, FI)) { 1719ddff941357bd836243ed7004ab88db09490176d8David Greene if (FrameInfo->isSpillSlotObjectIndex(FI)) { 1720ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1721ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1722fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman O << MAI->getCommentString() << ' ' 1723fcafe44f564f61016dd2f9367d93c91dfda74c96Dan Gohman << MMO->getSize() << "-byte Folded Spill"; 1724ddff941357bd836243ed7004ab88db09490176d8David Greene Newline = true; 1725ddff941357bd836243ed7004ab88db09490176d8David Greene } 1726ddff941357bd836243ed7004ab88db09490176d8David Greene } 1727ddff941357bd836243ed7004ab88db09490176d8David Greene 1728ddff941357bd836243ed7004ab88db09490176d8David Greene // Check for spill-induced copies 1729ddff941357bd836243ed7004ab88db09490176d8David Greene unsigned SrcReg, DstReg, SrcSubIdx, DstSubIdx; 1730ddff941357bd836243ed7004ab88db09490176d8David Greene if (TM.getInstrInfo()->isMoveInstr(MI, SrcReg, DstReg, 1731ddff941357bd836243ed7004ab88db09490176d8David Greene SrcSubIdx, DstSubIdx)) { 1732ddff941357bd836243ed7004ab88db09490176d8David Greene if (MI.getAsmPrinterFlag(ReloadReuse)) { 1733ddff941357bd836243ed7004ab88db09490176d8David Greene if (Newline) O << '\n'; 1734ddff941357bd836243ed7004ab88db09490176d8David Greene O.PadToColumn(MAI->getCommentColumn()); 1735ddff941357bd836243ed7004ab88db09490176d8David Greene O << MAI->getCommentString() << " Reload Reuse"; 1736ddff941357bd836243ed7004ab88db09490176d8David Greene } 1737ddff941357bd836243ed7004ab88db09490176d8David Greene } 1738014700c1a8cba203fd21ff129426ba8a426ab244David Greene} 1739014700c1a8cba203fd21ff129426ba8a426ab244David Greene 1740