AsmPrinter.cpp revision 98cdab53c302a2d6686fa428c0e896b1fb195311
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 1414c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#define DEBUG_TYPE "asm-printer" 15932f022b826c7b0b821c6a5369e18e4ebdceeb4cEvan Cheng#include "llvm/CodeGen/AsmPrinter.h" 16246ae0dcf750401ee84e1319ebe0b790744097a5Evan Cheng#include "llvm/Assembly/Writer.h" 178cfa57b1b4eade4e0101195b2f94ab288cd03563Nate Begeman#include "llvm/DerivedTypes.h" 18a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner#include "llvm/Constants.h" 19450de393acdf4be89db8558522b04d8111e4562bChris Lattner#include "llvm/Module.h" 2045111d160cf0910030eeb6a949c69273502e5ad5Chris Lattner#include "llvm/CodeGen/DwarfWriter.h" 215eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen#include "llvm/CodeGen/GCMetadataPrinter.h" 223b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner#include "llvm/CodeGen/MachineConstantPool.h" 231924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene#include "llvm/CodeGen/MachineFrameInfo.h" 24fe37ab335be5632eab561d49984c95cb06b946d4David Greene#include "llvm/CodeGen/MachineFunction.h" 2537efe6764568a3829fee26aba532283131d1a104Nate Begeman#include "llvm/CodeGen/MachineJumpTableInfo.h" 26b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene#include "llvm/CodeGen/MachineLoopInfo.h" 2784bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 28618f17702d09795279717827eeb06632d6ef49e4Dan Gohman#include "llvm/Analysis/ConstantFolding.h" 29cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis#include "llvm/Analysis/DebugInfo.h" 302b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner#include "llvm/MC/MCContext.h" 3152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner#include "llvm/MC/MCExpr.h" 323ac1ab835caacdeebbd0d7b4d69160f283928d21David Greene#include "llvm/MC/MCInst.h" 33a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner#include "llvm/MC/MCSection.h" 34a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner#include "llvm/MC/MCStreamer.h" 357cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner#include "llvm/MC/MCSymbol.h" 36af76e592c7f9deff0e55c13dbb4a34f07f1c7f64Chris Lattner#include "llvm/MC/MCAsmInfo.h" 3745111d160cf0910030eeb6a949c69273502e5ad5Chris Lattner#include "llvm/Target/Mangler.h" 3807000c6f01d8f57170f2d4c77a86d934bdc5c696Owen Anderson#include "llvm/Target/TargetData.h" 391924aabf996be9335fab34e7ee4fa2aa5911389cDavid Greene#include "llvm/Target/TargetInstrInfo.h" 400336fdba858830d515bf53ac29b8e5ff24dfa823Chris Lattner#include "llvm/Target/TargetLowering.h" 41f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner#include "llvm/Target/TargetLoweringObjectFile.h" 426547e406cf934346db7a206b61bcf09635afff0dEvan Cheng#include "llvm/Target/TargetOptions.h" 43da47e6e0d003c873da960361549e57ee4617c301Evan Cheng#include "llvm/Target/TargetRegisterInfo.h" 44cc41586b9d79532172b37e1f44a9077da4b73fc9Evan Cheng#include "llvm/ADT/SmallPtrSet.h" 45fad86b003a839cef40ec8ce8408322f4913368caChris Lattner#include "llvm/ADT/SmallString.h" 4614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#include "llvm/ADT/Statistic.h" 4714c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#include "llvm/Support/CommandLine.h" 4814c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#include "llvm/Support/Debug.h" 4914c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#include "llvm/Support/ErrorHandling.h" 5014c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#include "llvm/Support/Format.h" 5114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner#include "llvm/Support/FormattedStream.h" 526609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner#include <cerrno> 53a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerusing namespace llvm; 54a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 5514c38ec2afeaf25c53a50c2c65116aca8c889401Chris LattnerSTATISTIC(EmittedInsts, "Number of machine instrs printed"); 5614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 571997473cf72957d0e70322e2fe6fe2ab141c58a6Devang Patelchar AsmPrinter::ID = 0; 5871847813bc419f7a0667468136a07429c6d9f164David GreeneAsmPrinter::AsmPrinter(formatted_raw_ostream &o, TargetMachine &tm, 5956591ab218639d8a6e4c756ca37adaf20215c3b6Chris Lattner MCContext &Ctx, MCStreamer &Streamer, 6056591ab218639d8a6e4c756ca37adaf20215c3b6Chris Lattner const MCAsmInfo *T) 61b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner : MachineFunctionPass(&ID), O(o), 6233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner TM(tm), MAI(T), TRI(tm.getRegisterInfo()), 6356591ab218639d8a6e4c756ca37adaf20215c3b6Chris Lattner OutContext(Ctx), OutStreamer(Streamer), 640d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner LastMI(0), LastFn(0), Counter(~0U), SetCounter(0), PrevDLT(NULL) { 650de1fc4f416b3e94749ca84cdaede55b040a8b60Chris Lattner DW = 0; MMI = 0; 6656591ab218639d8a6e4c756ca37adaf20215c3b6Chris Lattner VerboseAsm = Streamer.isVerboseAsm(); 6742bf74be1402df7409efbea089310d4c276fde37Evan Cheng} 68ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 69c317a60c2714a5b90700a11ba646285cb754a5d3Gordon HenriksenAsmPrinter::~AsmPrinter() { 70c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen for (gcp_iterator I = GCMetadataPrinters.begin(), 71c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen E = GCMetadataPrinters.end(); I != E; ++I) 72c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen delete I->second; 732b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 742b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner delete &OutStreamer; 752b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner delete &OutContext; 76c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen} 77ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 78b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner/// getFunctionNumber - Return a unique ID for the current function. 79b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner/// 80b84822fb7b64977c16e97b870891da1d6c9736feChris Lattnerunsigned AsmPrinter::getFunctionNumber() const { 81b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner return MF->getFunctionNumber(); 82b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner} 83b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner 8438c398808cff7defdf013fa750dfac8e66302975Chris LattnerTargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { 85f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner return TM.getTargetLowering()->getObjFileLowering(); 86f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner} 87f0144127b98425d214e59e4a1a4b342b78e3642bChris Lattner 88dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner/// getCurrentSection() - Return the current section we are emitting to. 89dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattnerconst MCSection *AsmPrinter::getCurrentSection() const { 90dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner return OutStreamer.getCurrentSection(); 91b5a32e2e8ce2f3de3a340c5a2dfcd3a159968466Anton Korobeynikov} 924632d7a57008564c4b0f8246e85bd813a200d2c6Chris Lattner 93dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner 94ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksenvoid AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { 95845012e6d31799c7fbd1193fa1af8ee2d12e9231Dan Gohman AU.setPreservesAll(); 96ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen MachineFunctionPass::getAnalysisUsage(AU); 975eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen AU.addRequired<GCModuleInfo>(); 98fe37ab335be5632eab561d49984c95cb06b946d4David Greene if (VerboseAsm) 99b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene AU.addRequired<MachineLoopInfo>(); 100ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen} 101ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 102a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerbool AsmPrinter::doInitialization(Module &M) { 103f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner // Initialize TargetLoweringObjectFile. 104f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner const_cast<TargetLoweringObjectFile&>(getObjFileLowering()) 105f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner .Initialize(OutContext, TM); 106f26e03bc7e30162197641406e37e662a15d80f7eChris Lattner 107c0dba723d119adc8c7b49c6d0e97d10eac4428fcChris Lattner Mang = new Mangler(*MAI); 1082c1b1597f244c836771b4f2668c0ae399d32a5e9Chris Lattner 109812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson // Allow the target to emit any magic that it wants at the start of the file. 110812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson EmitStartOfAsmFile(M); 111952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola 112a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner // Very minimal debug info. It is ignored if we emit actual debug info. If we 113a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner // don't, this at least helps the user find where a global came from. 11433adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->hasSingleParameterDotFile()) { 115a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner // .file "foo.c" 116a6594fc7156c0afbe6fd5a6aab9b099aaf950c53Chris Lattner OutStreamer.EmitFileDirective(M.getModuleIdentifier()); 117952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola } 118952b839ce9bc0c6d605d8b202c9cd76f7f05a77dRafael Espindola 119812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 120812209a58c5520c604bc9279aa069e5ae066e860Bob Wilson assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 1215eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I) 1225eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) 12333adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MP->beginAssembly(O, *this, *MAI); 124ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 1253e2fa7a746270452316523f27b9055b007feba32Chris Lattner if (!M.getModuleInlineAsm().empty()) 12633adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << " Start of file scope inline assembly\n" 1273e2fa7a746270452316523f27b9055b007feba32Chris Lattner << M.getModuleInlineAsm() 12833adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner << '\n' << MAI->getCommentString() 129563321a2582851c653d0863e8e0bba3d483734f9Jim Laskey << " End of file scope inline assembly\n"; 1302c1b1597f244c836771b4f2668c0ae399d32a5e9Chris Lattner 131b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner MMI = getAnalysisIfAvailable<MachineModuleInfo>(); 132b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner if (MMI) 133b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner MMI->AnalyzeModule(M); 134b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner DW = getAnalysisIfAvailable<DwarfWriter>(); 1359a501cf19dbf1f56f0782ddba4c1931565af9610Sanjiv Gupta if (DW) 136b55e068e53fccc609b7d9cd198ed9818c188a196Chris Lattner DW->BeginModule(&M, MMI, O, this, MAI); 13714a55d952cf238fff42da53a75f39cf06dab184bDevang Patel 138a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner return false; 139a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 140a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 141be9dfcef82c58063708e039bea3cf972ba41581bChris Lattnervoid AsmPrinter::EmitLinkage(unsigned Linkage, MCSymbol *GVSym) const { 142a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner switch ((GlobalValue::LinkageTypes)Linkage) { 143a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::CommonLinkage: 144a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::LinkOnceAnyLinkage: 145a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::LinkOnceODRLinkage: 146a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::WeakAnyLinkage: 147a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::WeakODRLinkage: 148a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::LinkerPrivateLinkage: 149a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner if (MAI->getWeakDefDirective() != 0) { 150a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .globl _foo 151a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 152a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .weak_definition _foo 153a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefinition); 154a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } else if (const char *LinkOnce = MAI->getLinkOnceDirective()) { 155a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .globl _foo 156a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 157a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // FIXME: linkonce should be a section attribute, handled by COFF Section 158a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // assignment. 159a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // http://sourceware.org/binutils/docs-2.20/as/Linkonce.html#Linkonce 160111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner // .linkonce discard 161111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner // FIXME: It would be nice to use .linkonce samesize for non-common 162111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner // globals. 163a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner O << LinkOnce; 164a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } else { 165a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .weak _foo 166a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); 167a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } 168a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner break; 169a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::DLLExportLinkage: 170a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::AppendingLinkage: 171a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // FIXME: appending linkage variables should go into a section of 172a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // their name or something. For now, just emit them as external. 173a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::ExternalLinkage: 174a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // If external or appending, declare as a global symbol. 175a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner // .globl _foo 176a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 177a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner break; 178a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::PrivateLinkage: 179a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner case GlobalValue::InternalLinkage: 180a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner break; 181a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner default: 182a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner llvm_unreachable("Unknown linkage type!"); 183a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner } 184a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner} 185a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner 186a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner 18748d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner/// EmitGlobalVariable - Emit the specified global variable to the .s file. 18848d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattnervoid AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { 18948d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner if (!GV->hasInitializer()) // External globals require no code. 19048d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner return; 19148d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 19248d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner // Check to see if this is a special global used by LLVM, if so, emit it. 19348d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner if (EmitSpecialLLVMGlobal(GV)) 19448d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner return; 19574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 19674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner MCSymbol *GVSym = GetGlobalValueSymbol(GV); 197be9dfcef82c58063708e039bea3cf972ba41581bChris Lattner EmitVisibility(GVSym, GV->getVisibility()); 19874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 199a800f7c464ef9a376057a555129f36d1f8488c3bChris Lattner if (MAI->hasDotTypeDotSizeDirective()) 200a800f7c464ef9a376057a555129f36d1f8488c3bChris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); 20174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 20274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM); 20374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 20474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner const TargetData *TD = TM.getTargetData(); 20574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner unsigned Size = TD->getTypeAllocSize(GV->getType()->getElementType()); 20674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner unsigned AlignLog = TD->getPreferredAlignmentLog(GV); 20774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 2089744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner // Handle common and BSS local symbols (.lcomm). 2099744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner if (GVKind.isCommon() || GVKind.isBSSLocal()) { 21074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. 21174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 21274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (VerboseAsm) { 2130fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), GV, 2140fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner /*PrintType=*/false, GV->getParent()); 2150fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << '\n'; 21674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 217814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 218814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // Handle common symbols. 2199744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner if (GVKind.isCommon()) { 2209744d611d7c7c1fb51c50c4e94901e4e9a905116Chris Lattner // .comm _foo, 42, 4 2214ed5438f4882c9fe779b1a8ff546877889b222dfChris Lattner OutStreamer.EmitCommonSymbol(GVSym, Size, 1 << AlignLog); 222814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 223814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner } 224814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 225814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // Handle local BSS symbols. 226814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner if (MAI->hasMachoZeroFillDirective()) { 227814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner const MCSection *TheSection = 228814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 229814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .zerofill __DATA, __bss, _foo, 400, 5 230814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 231814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 232814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner } 233814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 2349eb158d5b4cd4f6fc80912e2dd77bdf13c3ca0e7Chris Lattner if (MAI->hasLCOMMDirective()) { 235814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .lcomm _foo, 42 2369eb158d5b4cd4f6fc80912e2dd77bdf13c3ca0e7Chris Lattner OutStreamer.EmitLocalCommonSymbol(GVSym, Size); 237814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner return; 23874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 239814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner 240814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .local _foo 241a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Local); 242814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner // .comm _foo, 42, 4 243814819f6ea7fb0638fe73920299fda0da941a59eChris Lattner OutStreamer.EmitCommonSymbol(GVSym, Size, 1 << AlignLog); 24474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner return; 24574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 24648d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 24774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner const MCSection *TheSection = 24874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 24974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 25074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // Handle the zerofill directive on darwin, which is a special form of BSS 25174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // emission. 25274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (GVKind.isBSSExtern() && MAI->hasMachoZeroFillDirective()) { 25374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .globl _foo 254a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 25574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner // .zerofill __DATA, __common, _foo, 400, 5 25674bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 25774bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner return; 25874bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 25974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 26074bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner OutStreamer.SwitchSection(TheSection); 26174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 262a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner EmitLinkage(GV->getLinkage(), GVSym); 26374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner EmitAlignment(AlignLog, GV); 264a3e8883d710c435d640d65e52f0c6dcce21cad5bChris Lattner 26574bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (VerboseAsm) { 2660fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), GV, 2670fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner /*PrintType=*/false, GV->getParent()); 2680fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << '\n'; 26974bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner } 2704c8c668b57f74e2849ba198c3abfc97899e8072bChris Lattner OutStreamer.EmitLabel(GVSym); 27174bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 27274bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner EmitGlobalConstant(GV->getInitializer()); 27374bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner 27474bfe21b50c14c15f55ce3bd5857d65b588fae3cChris Lattner if (MAI->hasDotTypeDotSizeDirective()) 2751947f242d40227d36440a2702a0a612c8077d72eChris Lattner // .size foo, 42 27699328add833807f12a4950c7de29fb2a5df04703Chris Lattner OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext)); 2770fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner 2780fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddBlankLine(); 27948d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner} 28048d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 281b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner/// EmitFunctionHeader - This method emits the header for the current 282b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner/// function. 283b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattnervoid AsmPrinter::EmitFunctionHeader() { 284b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Print out constants referenced by the function 285a2406190ca28dc5901dfe747849c8eda9c29d7eeChris Lattner EmitConstantPool(); 286b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 287b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Print the 'header' of function. 288b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner const Function *F = MF->getFunction(); 289b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 290b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); 291be9dfcef82c58063708e039bea3cf972ba41581bChris Lattner EmitVisibility(CurrentFnSym, F->getVisibility()); 292b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 293111a3193b5e25f8765221f2e94fba888155fe4ebChris Lattner EmitLinkage(F->getLinkage(), CurrentFnSym); 294b406a8141d704bca7a8eade3a0c46d7ec73affc8Chris Lattner EmitAlignment(MF->getAlignment(), F); 295b406a8141d704bca7a8eade3a0c46d7ec73affc8Chris Lattner 296b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (MAI->hasDotTypeDotSizeDirective()) 297b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner OutStreamer.EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction); 298b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 299b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (VerboseAsm) { 3009bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner WriteAsOperand(OutStreamer.GetCommentOS(), F, 3019bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner /*PrintType=*/false, F->getParent()); 3029bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner OutStreamer.GetCommentOS() << '\n'; 303b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner } 304b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 305f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // Emit the CurrentFnSym. This is a virtual function to allow targets to 3062cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner // do their wild and crazy things as required. 3072cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner EmitFunctionEntryLabel(); 3082cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner 309b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Add some workaround for linkonce linkage on Cygwin\MinGW. 310b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (MAI->getLinkOnceDirective() != 0 && 311b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner (F->hasLinkOnceLinkage() || F->hasWeakLinkage())) 3129bc20ab519d47146a9716d7cff2a892da78774a6Chris Lattner // FIXME: What is this? 313b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner O << "Lllvm$workaround$fake$stub$" << *CurrentFnSym << ":\n"; 314b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 315b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner // Emit pre-function debug and/or EH information. 316b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner if (MAI->doesSupportDebugInformation() || MAI->doesSupportExceptionHandling()) 317b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner DW->BeginFunction(MF); 318b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner} 319b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 3202cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the 3212cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner/// function. This can be overridden by targets as required to do custom stuff. 3222cf7251d39f28888af06b6f941eabd1d10995382Chris Lattnervoid AsmPrinter::EmitFunctionEntryLabel() { 3232cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner OutStreamer.EmitLabel(CurrentFnSym); 3242cf7251d39f28888af06b6f941eabd1d10995382Chris Lattner} 325b11caedd6f36afc6518cf0ea9bbff6500fd77334Chris Lattner 32648d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner 32747529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner/// EmitComments - Pretty-print comments for instructions. 32847529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattnerstatic void EmitComments(const MachineInstr &MI, raw_ostream &CommentOS) { 32947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner const MachineFunction *MF = MI.getParent()->getParent(); 33047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner const TargetMachine &TM = MF->getTarget(); 33147529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 33247529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (!MI.getDebugLoc().isUnknown()) { 33347529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner DILocation DLT = MF->getDILocation(MI.getDebugLoc()); 33447529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 33547529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner // Print source line info. 33647529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner DIScope Scope = DLT.getScope(); 33747529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner // Omit the directory, because it's likely to be long and uninteresting. 3383c91b05d2b1751b9e4e21fd958d358ec463dcd3cDevang Patel if (Scope.Verify()) 33947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << Scope.getFilename(); 34047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner else 34147529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << "<unknown>"; 34247529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << ':' << DLT.getLineNumber(); 34347529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (DLT.getColumnNumber() != 0) 34447529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << ':' << DLT.getColumnNumber(); 34547529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << '\n'; 34647529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } 34747529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 34847529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner // Check for spills and reloads 34947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner int FI; 35047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 35147529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner const MachineFrameInfo *FrameInfo = MF->getFrameInfo(); 35247529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 35347529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner // We assume a single instruction only has a spill or reload, not 35447529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner // both. 35547529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner const MachineMemOperand *MMO; 35647529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (TM.getInstrInfo()->isLoadFromStackSlotPostFE(&MI, FI)) { 35747529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (FrameInfo->isSpillSlotObjectIndex(FI)) { 35847529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner MMO = *MI.memoperands_begin(); 35947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << MMO->getSize() << "-byte Reload\n"; 36047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } 36147529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } else if (TM.getInstrInfo()->hasLoadFromStackSlot(&MI, MMO, FI)) { 36247529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (FrameInfo->isSpillSlotObjectIndex(FI)) 36347529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << MMO->getSize() << "-byte Folded Reload\n"; 36447529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } else if (TM.getInstrInfo()->isStoreToStackSlotPostFE(&MI, FI)) { 36547529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (FrameInfo->isSpillSlotObjectIndex(FI)) { 36647529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner MMO = *MI.memoperands_begin(); 36747529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << MMO->getSize() << "-byte Spill\n"; 36847529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } 36947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } else if (TM.getInstrInfo()->hasStoreToStackSlot(&MI, MMO, FI)) { 37047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (FrameInfo->isSpillSlotObjectIndex(FI)) 37147529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << MMO->getSize() << "-byte Folded Spill\n"; 37247529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } 37347529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 37447529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner // Check for spill-induced copies 37547529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner unsigned SrcReg, DstReg, SrcSubIdx, DstSubIdx; 37647529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (TM.getInstrInfo()->isMoveInstr(MI, SrcReg, DstReg, 37747529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner SrcSubIdx, DstSubIdx)) { 37845282aedb9c5a33d20565502c6c8fc871fa84cbeChris Lattner if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse)) 37947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner CommentOS << " Reload Reuse\n"; 38047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner } 38147529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner} 38247529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 38347529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 38447529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 38514c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner/// EmitFunctionBody - This method emits the body and trailer for a 38614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner/// function. 38714c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattnervoid AsmPrinter::EmitFunctionBody() { 388edfe776ac29d9fd48ae8967f6742400aad65e39cChris Lattner // Emit target-specific gunk before the function body. 389edfe776ac29d9fd48ae8967f6742400aad65e39cChris Lattner EmitFunctionBodyStart(); 390edfe776ac29d9fd48ae8967f6742400aad65e39cChris Lattner 39114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // Print out code for the function. 39214c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner bool HasAnyRealCode = false; 39314c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 39414c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner I != E; ++I) { 39514c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // Print a label for the basic block. 39614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner EmitBasicBlockStart(I); 39714c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 39814c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner II != IE; ++II) { 39914c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // Print the assembly for the instruction. 40014c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner if (!II->isLabel()) 40114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner HasAnyRealCode = true; 40214c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 40314c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner ++EmittedInsts; 40414c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 40514c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // FIXME: Clean up processDebugLoc. 40614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner processDebugLoc(II, true); 40714c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 40847529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner if (VerboseAsm) 40947529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner EmitComments(*II, OutStreamer.GetCommentOS()); 41047529c9ac6d4731e9f5a1b2d3c64769b1b2d5f1dChris Lattner 4110d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner switch (II->getOpcode()) { 412518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::DBG_LABEL: 413518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::EH_LABEL: 414518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::GC_LABEL: 415f64159c8402ef17d14b5f7555378b2c321a4a5abChris Lattner printLabelInst(II); 4160d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner break; 417518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::INLINEASM: 4180d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner printInlineAsm(II); 4190d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner break; 420518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::IMPLICIT_DEF: 4210d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner printImplicitDef(II); 4220d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner break; 423518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner case TargetOpcode::KILL: 4240d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner printKill(II); 4250d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner break; 4260d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner default: 4270d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner EmitInstruction(II); 4280d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner break; 4290d883e3f8484491d010b8f8b7a1aecc58cb5fa8eChris Lattner } 43014c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 43114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // FIXME: Clean up processDebugLoc. 43214c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner processDebugLoc(II, false); 43314c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner } 43414c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner } 43514c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 43614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // If the function is empty and the object file uses .subsections_via_symbols, 437d49fe1b6bc4615684c2ec71140a21e9c4cd69ce3Chris Lattner // then we need to emit *something* to the function body to prevent the 438d49fe1b6bc4615684c2ec71140a21e9c4cd69ce3Chris Lattner // labels from collapsing together. Just emit a 0 byte. 43910e7c60c0444a766c256f6c7c922e43963590a5cChris Lattner if (MAI->hasSubsectionsViaSymbols() && !HasAnyRealCode) 44010e7c60c0444a766c256f6c7c922e43963590a5cChris Lattner OutStreamer.EmitIntValue(0, 1, 0/*addrspace*/); 44114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 442edfe776ac29d9fd48ae8967f6742400aad65e39cChris Lattner // Emit target-specific gunk after the function body. 443edfe776ac29d9fd48ae8967f6742400aad65e39cChris Lattner EmitFunctionBodyEnd(); 444edfe776ac29d9fd48ae8967f6742400aad65e39cChris Lattner 44514c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner if (MAI->hasDotTypeDotSizeDirective()) 44614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner O << "\t.size\t" << *CurrentFnSym << ", .-" << *CurrentFnSym << '\n'; 44714c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 44814c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // Emit post-function debug information. 44914c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner if (MAI->doesSupportDebugInformation() || MAI->doesSupportExceptionHandling()) 45014c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner DW->EndFunction(MF); 45114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 45214c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner // Print out jump tables referenced by the function. 45314c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner EmitJumpTableInfo(); 454d26a80f666fb925956a4f19143265f5150756df0Chris Lattner 455d26a80f666fb925956a4f19143265f5150756df0Chris Lattner OutStreamer.AddBlankLine(); 45614c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner} 45714c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 45814c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner 459a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattnerbool AsmPrinter::doFinalization(Module &M) { 46040bbebde9d250b875a47a688d0c6552834ada48fChris Lattner // Emit global variables. 46140bbebde9d250b875a47a688d0c6552834ada48fChris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 46240bbebde9d250b875a47a688d0c6552834ada48fChris Lattner I != E; ++I) 46348d64ba9d846229339b2431b298620cb8a01ffc5Chris Lattner EmitGlobalVariable(I); 46440bbebde9d250b875a47a688d0c6552834ada48fChris Lattner 4651f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner // Emit final debug information. 46633adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->doesSupportDebugInformation() || MAI->doesSupportExceptionHandling()) 4671f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner DW->EndModule(); 4681f522feabf25134249bc7894e04f5b89fa071b7fChris Lattner 4690a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // If the target wants to know about weak references, print them all. 47033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner if (MAI->getWeakRefDirective()) { 4710a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // FIXME: This is not lazy, it would be nice to only print weak references 4720a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // to stuff that is actually used. Note that doing so would require targets 4730a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // to notice uses in operands (due to constant exprs etc). This should 4740a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // happen with the MC stuff eventually. 4750a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner 4760a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner // Print out module-level global variables here. 4770a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 4780a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner I != E; ++I) { 47908ce3b473d06e0f7806df3d44b7b36ac40c58803Chris Lattner if (!I->hasExternalWeakLinkage()) continue; 4803924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(I), 481a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_WeakReference); 4820a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner } 4830a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner 484c6fdced3dbfdf673cc9b01dfad4f08e316d8803dChris Lattner for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 48508ce3b473d06e0f7806df3d44b7b36ac40c58803Chris Lattner if (!I->hasExternalWeakLinkage()) continue; 4863924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(I), 487a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_WeakReference); 4880a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner } 48915404d060ba8b604c03b9223a0f2e2abcd0fddedRafael Espindola } 49015404d060ba8b604c03b9223a0f2e2abcd0fddedRafael Espindola 491cee63322eaccc2f1067bdf5eab506e440f867da1Chris Lattner if (MAI->hasSetDirective()) { 4923a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.AddBlankLine(); 4938b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 4940a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner I != E; ++I) { 4955c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner MCSymbol *Name = GetGlobalValueSymbol(I); 496325be7c608a37d87e4f3d731e11fa3dd34f529b5Anton Korobeynikov 497325be7c608a37d87e4f3d731e11fa3dd34f529b5Anton Korobeynikov const GlobalValue *GV = cast<GlobalValue>(I->getAliasedGlobal()); 4985c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner MCSymbol *Target = GetGlobalValueSymbol(GV); 4995c40e694dcd679bf26b962189c1d12b32fff07cdChris Lattner 50010b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner if (I->hasExternalLinkage() || !MAI->getWeakRefDirective()) 501a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(Name, MCSA_Global); 50210b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner else if (I->hasWeakLinkage()) 503a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner OutStreamer.EmitSymbolAttribute(Name, MCSA_WeakReference); 50410b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner else 50510595490ccf25b4960936638fac7a673eaf82e68Chris Lattner assert(I->hasLocalLinkage() && "Invalid alias linkage"); 50622c9e65643e0c6b43be37a19e59491ef0081092cAnton Korobeynikov 507be9dfcef82c58063708e039bea3cf972ba41581bChris Lattner EmitVisibility(Name, I->getVisibility()); 50822c9e65643e0c6b43be37a19e59491ef0081092cAnton Korobeynikov 509c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner // Emit the directives as assignments aka .set: 510c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner OutStreamer.EmitAssignment(Name, 511c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner MCSymbolRefExpr::Create(Target, OutContext)); 5128b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 5138b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov } 5148b0a8c84da2030ee8f4440d5b60a8033de691222Anton Korobeynikov 5151465d61bdd36cfd6021036a527895f0dd358e97dDuncan Sands GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 5165eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 5175eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) 5185eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*--I)) 51933adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner MP->finishAssembly(O, *this, *MAI); 520ce2247755e56f99a2377b64a1a9d393726582b85Gordon Henriksen 521a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman // If we don't have any trampolines, then we don't require stack memory 522a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman // to be executable. Some targets have a directive to declare this. 5230a7befa8bd56621f51eaf9196417b866962bf7b1Chris Lattner Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline"); 524a779a9899a5e23bd5198973f4709d66cb4bc2e64Dan Gohman if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty()) 525f9f93e4388962b678fd59b7af5212d4cc0d38be2Chris Lattner if (MCSection *S = MAI->getNonexecutableStackSection(OutContext)) 526f9f93e4388962b678fd59b7af5212d4cc0d38be2Chris Lattner OutStreamer.SwitchSection(S); 527bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner 528bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner // Allow the target to emit any magic that it wants at the end of the file, 529bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner // after everything else has gone out. 530bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner EmitEndOfAsmFile(M); 531bd23d5fda85e38c88dfa668a99777cd05c524822Chris Lattner 532a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner delete Mang; Mang = 0; 5330de1fc4f416b3e94749ca84cdaede55b040a8b60Chris Lattner DW = 0; MMI = 0; 5342b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner 5352b2954f00ba02ca1a902f47080cd9f06aebc0378Chris Lattner OutStreamer.Finish(); 536a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner return false; 537a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 538a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 53925045bdcda822d63674e2df7e34016536c5d3fa7Chris Lattnervoid AsmPrinter::SetupMachineFunction(MachineFunction &MF) { 540b84822fb7b64977c16e97b870891da1d6c9736feChris Lattner this->MF = &MF; 541412c3a5bc9e70fe8579551216786e70d323a3dd5Chris Lattner // Get the function symbol. 542d1947ed2f824d2e9f4923fb6efc2aec4a6e3e96dChris Lattner CurrentFnSym = GetGlobalValueSymbol(MF.getFunction()); 543b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene 54425d812bd7d1f58f2ba1b598b1425a2e146e27381Chris Lattner if (VerboseAsm) 545b71d1b2fe2c0673005283b48be2f37c750ce367bDavid Greene LI = &getAnalysis<MachineLoopInfo>(); 546a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 547a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner 5481606e8e4cd937e6de6681f686c266cf61722d972Evan Chengnamespace { 5491606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // SectionCPs - Keep track the alignment, constpool entries per Section. 5501606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng struct SectionCPs { 551a87dea4f8c546ca748f1777a8d1cabcc06515d91Chris Lattner const MCSection *S; 5521606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Alignment; 5531606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SmallVector<unsigned, 4> CPEs; 554cabdd7425d30f7eb659ecb0cc5efbc4052dd78a8Douglas Gregor SectionCPs(const MCSection *s, unsigned a) : S(s), Alignment(a) {} 5551606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng }; 5561606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng} 5571606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 5583b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// EmitConstantPool - Print to the current output stream assembly 5593b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// representations of the constants in the constant pool MCP. This is 5603b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// used to print out constants which have been "spilled to memory" by 5613b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// the code generator. 5623b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner/// 563a2406190ca28dc5901dfe747849c8eda9c29d7eeChris Lattnervoid AsmPrinter::EmitConstantPool() { 564a2406190ca28dc5901dfe747849c8eda9c29d7eeChris Lattner const MachineConstantPool *MCP = MF->getConstantPool(); 565fa77d43ba1d91ed39f46e11caeb28dcabae9e193Chris Lattner const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); 5663b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner if (CP.empty()) return; 5672d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 568088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // Calculate sections for constant pool entries. We collect entries to go into 569088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // the same section together to reduce amount of section switch statements. 5701606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SmallVector<SectionCPs, 4> CPSections; 5712d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng for (unsigned i = 0, e = CP.size(); i != e; ++i) { 572298414ec1891ce8d3a1b69e6019ad8765c8e69dcChris Lattner const MachineConstantPoolEntry &CPE = CP[i]; 5731606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Align = CPE.getAlignment(); 5745c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner 5755c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner SectionKind Kind; 5765c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner switch (CPE.getRelocationInfo()) { 5775c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner default: llvm_unreachable("Unknown section kind"); 5782798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 2: Kind = SectionKind::getReadOnlyWithRel(); break; 5794c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner case 1: 5802798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner Kind = SectionKind::getReadOnlyWithRelLocal(); 5814c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner break; 5825c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner case 0: 5834c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { 5842798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 4: Kind = SectionKind::getMergeableConst4(); break; 5852798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 8: Kind = SectionKind::getMergeableConst8(); break; 5862798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner case 16: Kind = SectionKind::getMergeableConst16();break; 5872798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner default: Kind = SectionKind::getMergeableConst(); break; 5884c50922f6be96fdb1e9a924aeeecf91638e2c52bChris Lattner } 5895c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner } 5905c2f789952ff315021afb10381f141f2ac3b1a6bChris Lattner 59183d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner const MCSection *S = getObjFileLowering().getSectionForConstant(Kind); 592298414ec1891ce8d3a1b69e6019ad8765c8e69dcChris Lattner 5931606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // The number of sections are small, just do a linear search from the 5941606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // last section to the first. 5951606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng bool Found = false; 5961606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned SecIdx = CPSections.size(); 5971606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng while (SecIdx != 0) { 5981606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (CPSections[--SecIdx].S == S) { 5991606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng Found = true; 6001606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng break; 6011606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 6021606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 6031606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (!Found) { 6041606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng SecIdx = CPSections.size(); 6051606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections.push_back(SectionCPs(S, Align)); 6061606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 6071606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 6081606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (Align > CPSections[SecIdx].Alignment) 6091606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections[SecIdx].Alignment = Align; 6101606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng CPSections[SecIdx].CPEs.push_back(i); 6112d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng } 6122d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 613088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov // Now print stuff into the calculated sections. 6141606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng for (unsigned i = 0, e = CPSections.size(); i != e; ++i) { 6156c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(CPSections[i].S); 6161606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitAlignment(Log2_32(CPSections[i].Alignment)); 6172d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 6181606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned Offset = 0; 6191606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) { 6201606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned CPI = CPSections[i].CPEs[j]; 6211606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng MachineConstantPoolEntry CPE = CP[CPI]; 6221606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 6231606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng // Emit inter-object padding for alignment. 6241606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned AlignMask = CPE.getAlignment() - 1; 6251606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng unsigned NewOffset = (Offset + AlignMask) & ~AlignMask; 626aaec205b87637cd0d59d4f11630db603686eb73dChris Lattner OutStreamer.EmitFill(NewOffset - Offset, 0/*fillval*/, 0/*addrspace*/); 6271606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng 6281606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng const Type *Ty = CPE.getType(); 629777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands Offset = NewOffset + TM.getTargetData()->getTypeAllocSize(Ty); 6302d2cec1e9e93a388bd8448f4bad661ac89a49de3Evan Cheng 6313924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner // Emit the label with a comment on it. 6321606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (VerboseAsm) { 6333924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.GetCommentOS() << "constant pool "; 6343924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner WriteTypeSymbolic(OutStreamer.GetCommentOS(), CPE.getType(), 6353924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner MF->getFunction()->getParent()); 6363924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.GetCommentOS() << '\n'; 6371606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng } 6383924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner OutStreamer.EmitLabel(GetCPISymbol(CPI)); 6393924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 6401606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng if (CPE.isMachineConstantPoolEntry()) 6411606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitMachineConstantPoolValue(CPE.Val.MachineCPVal); 642088ae8393f124564ca9ab70654645aa656e5646fAnton Korobeynikov else 6431606e8e4cd937e6de6681f686c266cf61722d972Evan Cheng EmitGlobalConstant(CPE.Val.ConstVal); 6443029f920519e0871a5aad5d7c592281093953733Chris Lattner } 6453b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner } 6463b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner} 6473b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner 64837efe6764568a3829fee26aba532283131d1a104Nate Begeman/// EmitJumpTableInfo - Print assembly representations of the jump tables used 64937efe6764568a3829fee26aba532283131d1a104Nate Begeman/// by the current function to the current output stream. 65037efe6764568a3829fee26aba532283131d1a104Nate Begeman/// 65114c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattnervoid AsmPrinter::EmitJumpTableInfo() { 65214c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); 65344e87255e9b7a9d8ecb558690db1181882c08045Chris Lattner if (MJTI == 0) return; 65437efe6764568a3829fee26aba532283131d1a104Nate Begeman const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 65537efe6764568a3829fee26aba532283131d1a104Nate Begeman if (JT.empty()) return; 6569de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 6572f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman // Pick the directive to use to print the jump table entries, and switch to 6582f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman // the appropriate section. 65914c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner const Function *F = MF->getFunction(); 660b13bafe5c12dd908b55c559c93adaeb1627ed096Evan Cheng bool JTInDiffSection = false; 661f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner if (// In PIC mode, we need to emit the jump table to the same section as the 662f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // function body itself, otherwise the label differences won't make sense. 663f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // FIXME: Need a better predicate for this: what about custom entries? 664f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 || 665f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // We should also do if the section name is NULL or function is declared 666f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // in discardable section 667f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // FIXME: this isn't the right predicate, should be based on the MCSection 668f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner // for the function. 669f1214cbf3c2d151d3a2353d82143da186313a42aChris Lattner F->isWeakForLinker()) { 67014c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F,Mang,TM)); 6712f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } else { 67283d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner // Otherwise, drop it in the readonly section. 67383d77faf6e8fc2c1c2377d037283dc162d8667a1Chris Lattner const MCSection *ReadOnlySection = 6742798119ab4d7e0b42812b3acdf37821f40dee627Chris Lattner getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly()); 6756c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(ReadOnlySection); 676b13bafe5c12dd908b55c559c93adaeb1627ed096Evan Cheng JTInDiffSection = true; 6772f1ae88445c696a9b9d61e14747ba721190cdc99Nate Begeman } 678071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner 679071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner EmitAlignment(Log2_32(MJTI->getEntryAlignment(*TM.getTargetData()))); 6800c4e6789da4dba6c7b0010886776b24dec3f3bb8Chris Lattner 6813b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) { 6823b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; 68307371882208f913d18a7f2a47373eaee7138416bChris Lattner 68407371882208f913d18a7f2a47373eaee7138416bChris Lattner // If this jump table was deleted, ignore it. 68507371882208f913d18a7f2a47373eaee7138416bChris Lattner if (JTBBs.empty()) continue; 68652a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 687e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner // For the EK_LabelDifference32 entry, if the target supports .set, emit a 688e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner // .set directive for each unique entry. This reduces the number of 689e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner // relocations the assembler will generate for the jump table. 690e35df92eca194365f984f9d24a74e4ddd6669c40Chris Lattner if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 && 691cee63322eaccc2f1067bdf5eab506e440f867da1Chris Lattner MAI->hasSetDirective()) { 6923b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets; 6933b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const TargetLowering *TLI = TM.getTargetLowering(); 69414c38ec2afeaf25c53a50c2c65116aca8c889401Chris Lattner const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF,JTI,OutContext); 6953b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { 6963b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner const MachineBasicBlock *MBB = JTBBs[ii]; 6973b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner if (!EmittedSets.insert(MBB)) continue; 6983b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner 699c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner // .set LJTSet, LBB32-base 700c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner const MCExpr *LHS = 701c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner MCSymbolRefExpr::Create(MBB->getSymbol(OutContext), OutContext); 702c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner OutStreamer.EmitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()), 703c618c8aff46a8ec4d209d041404e780a0caaf77dChris Lattner MCBinaryExpr::CreateSub(LHS, Base, OutContext)); 7043b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner } 7053b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner } 70652a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 7077c30191393c99c9ba804f1a01942a9e130c53904Chris Lattner // On some targets (e.g. Darwin) we want to emit two consequtive labels 708393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // before each jump table. The first label is never referenced, but tells 709393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // the assembler and linker the extents of the jump table object. The 710393a8eea3c15de08eaf6953aa8a65a3961b76153Chris Lattner // second label is actually referenced by the code. 7113924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner if (JTInDiffSection && MAI->getLinkerPrivateGlobalPrefix()[0]) 712beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner // FIXME: This doesn't have to have any specific name, just any randomly 713beeb93e6ba48af2661eabc4872d8b159fb43e5dbChris Lattner // named and numbered 'l' label would work. Simplify GetJTISymbol. 7143b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner OutStreamer.EmitLabel(GetJTISymbol(JTI, true)); 7153924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 7163b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner OutStreamer.EmitLabel(GetJTISymbol(JTI)); 7173924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 7186bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) 7193b131d7cc4dc4bbb329c136705b37dc255995fbdChris Lattner EmitJumpTableEntry(MJTI, JTBBs[ii], JTI); 72037efe6764568a3829fee26aba532283131d1a104Nate Begeman } 72137efe6764568a3829fee26aba532283131d1a104Nate Begeman} 72237efe6764568a3829fee26aba532283131d1a104Nate Begeman 7236bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the 7246bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner/// current stream. 7256bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattnervoid AsmPrinter::EmitJumpTableEntry(const MachineJumpTableInfo *MJTI, 7266bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner const MachineBasicBlock *MBB, 7276bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner unsigned UID) const { 728ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner const MCExpr *Value = 0; 729ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner switch (MJTI->getEntryKind()) { 73085fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner case MachineJumpTableInfo::EK_Custom32: 7316bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner Value = TM.getTargetLowering()->LowerCustomJumpTableEntry(MJTI, MBB, UID, 73285fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner OutContext); 73385fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner break; 734ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner case MachineJumpTableInfo::EK_BlockAddress: 735ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // EK_BlockAddress - Each entry is a plain address of block, e.g.: 736ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .word LBB123 737f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner Value = MCSymbolRefExpr::Create(MBB->getSymbol(OutContext), OutContext); 738ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner break; 739ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner case MachineJumpTableInfo::EK_GPRel32BlockAddress: { 740ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // EK_GPRel32BlockAddress - Each entry is an address of block, encoded 741ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // with a relocation as gp-relative, e.g.: 742ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .gprel32 LBB123 743f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner MCSymbol *MBBSym = MBB->getSymbol(OutContext); 744718fb59801320b8cb22363d115b5fc5ec40dc1f5Chris Lattner OutStreamer.EmitGPRel32Value(MCSymbolRefExpr::Create(MBBSym, OutContext)); 74578f485afb723121eedf4b6907ae6eb53da8af03cChris Lattner return; 7469de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } 74785fe07866a3b240d9facef3b2f2ea81a0a8db018Chris Lattner 748ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner case MachineJumpTableInfo::EK_LabelDifference32: { 749ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // EK_LabelDifference32 - Each entry is the address of the block minus 750ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // the address of the jump table. This is used for PIC jump tables where 751ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // gprel32 is not supported. e.g.: 752ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .word LBB123 - LJTI1_2 753ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // If the .set directive is supported, this is emitted as: 754ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .set L4_5_set_123, LBB123 - LJTI1_2 755ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // .word L4_5_set_123 756ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner 757ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // If we have emitted set directives for the jump table entries, print 758ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // them rather than the entries themselves. If we're emitting PIC, then 759ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // emit the table entries as differences between two text section labels. 760cee63322eaccc2f1067bdf5eab506e440f867da1Chris Lattner if (MAI->hasSetDirective()) { 761ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner // If we used .set, reference the .set's symbol. 7626bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner Value = MCSymbolRefExpr::Create(GetJTSetSymbol(UID, MBB->getNumber()), 763ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner OutContext); 764ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner break; 765ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner } 7661aca2492526c0a1aa464f2993084f9b30b53c009Chris Lattner // Otherwise, use the difference as the jump table entry. 767f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner Value = MCSymbolRefExpr::Create(MBB->getSymbol(OutContext), OutContext); 7686bf1def1598f9c7a699ce4874e7d2575212b4232Chris Lattner const MCExpr *JTI = MCSymbolRefExpr::Create(GetJTISymbol(UID), OutContext); 769ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner Value = MCBinaryExpr::CreateSub(Value, JTI, OutContext); 770ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner break; 771ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner } 7729de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov } 7731aca2492526c0a1aa464f2993084f9b30b53c009Chris Lattner 774ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner assert(Value && "Unknown entry kind!"); 775ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner 776071c62fad0b25ad4131e7f984173a796c1e63f61Chris Lattner unsigned EntrySize = MJTI->getEntrySize(*TM.getTargetData()); 777ff537cec2e7ee34d6879de0c8a39a3c65f6ab003Chris Lattner OutStreamer.EmitValue(Value, EntrySize, /*addrspace*/0); 7789de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov} 7799de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 7809de1934099f4eedaeb2f3a023411b2cd3e0e1eaeAnton Korobeynikov 781ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// EmitSpecialLLVMGlobal - Check to see if the specified global is a 782ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// special global used by LLVM. If so, emit it and return true, otherwise 783ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// do nothing and return false. 784ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattnerbool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { 78503d7651c3652e1f0cc86e79b26585d86818da9cfDaniel Dunbar if (GV->getName() == "llvm.used") { 7863a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner if (MAI->hasNoDeadStrip()) // No need to emit this at all. 787b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth EmitLLVMUsedList(GV->getInitializer()); 788b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth return true; 789b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth } 790b753a9bb6277cd34ffc55f8674087ff8c3097a11Andrew Lenharth 791401e10c4fbfcdcfade5065093e2ca97f69a1d144Chris Lattner // Ignore debug and non-emitted data. This handles llvm.compiler.used. 792266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner if (GV->getSection() == "llvm.metadata" || 793266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner GV->hasAvailableExternallyLinkage()) 794266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner return true; 7957809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey 7967809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey if (!GV->hasAppendingLinkage()) return false; 7977809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey 7987809811e4ed3c2462efa327cef0464b9844baea2Jim Laskey assert(GV->hasInitializer() && "Not a special LLVM global!"); 799ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 800916d07cdfa89e77118043ec6e14575512ae1bf85Evan Cheng const TargetData *TD = TM.getTargetData(); 801916d07cdfa89e77118043ec6e14575512ae1bf85Evan Cheng unsigned Align = Log2_32(TD->getPointerPrefAlignment()); 802f231c07228deb75b6cd5ae7c9c057bc8303c6998Chris Lattner if (GV->getName() == "llvm.global_ctors") { 8036c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().getStaticCtorSection()); 804ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitAlignment(Align, 0); 805ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitXXStructorList(GV->getInitializer()); 80671eae713153e564ec743c5c4162ff258c255de78Chris Lattner 80771eae713153e564ec743c5c4162ff258c255de78Chris Lattner if (TM.getRelocationModel() == Reloc::Static && 8083a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner MAI->hasStaticCtorDtorReferenceInStaticMode()) { 8093a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner StringRef Sym(".constructors_used"); 8103a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 811a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_Reference); 8123a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner } 813ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner return true; 814ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 815ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 816f231c07228deb75b6cd5ae7c9c057bc8303c6998Chris Lattner if (GV->getName() == "llvm.global_dtors") { 8176c2f9e14fdf14d8c1c687c6bd9918183fa7f8a7fChris Lattner OutStreamer.SwitchSection(getObjFileLowering().getStaticDtorSection()); 818ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitAlignment(Align, 0); 819ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner EmitXXStructorList(GV->getInitializer()); 82071eae713153e564ec743c5c4162ff258c255de78Chris Lattner 82171eae713153e564ec743c5c4162ff258c255de78Chris Lattner if (TM.getRelocationModel() == Reloc::Static && 8223a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner MAI->hasStaticCtorDtorReferenceInStaticMode()) { 8233a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner StringRef Sym(".destructors_used"); 8243a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 825a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_Reference); 8263a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner } 827ea3a9ff53d699bc22fcff52dbbce8aab6578a020Chris Lattner return true; 828ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 829ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 830ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner return false; 831ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner} 832ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner 83333adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each 834d2e51af0358b571367a9f1e5175b87e9dd72edf8Dale Johannesen/// global in the specified llvm.used list for which emitUsedDirectiveFor 835d2e51af0358b571367a9f1e5175b87e9dd72edf8Dale Johannesen/// is true, as being used with this directive. 836cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattnervoid AsmPrinter::EmitLLVMUsedList(Constant *List) { 837a119de86a064414622562cfe32953de7f9b0ee40Dan Gohman // Should be an array of 'i8*'. 838cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner ConstantArray *InitList = dyn_cast<ConstantArray>(List); 839cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner if (InitList == 0) return; 840cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner 841cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 84216fe990e56102a355f1e77aca93bf8c79d7b9eb2Chris Lattner const GlobalValue *GV = 84316fe990e56102a355f1e77aca93bf8c79d7b9eb2Chris Lattner dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts()); 8443a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner if (GV && getObjFileLowering().shouldEmitUsedDirectiveFor(GV, Mang)) 8453a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner OutStreamer.EmitSymbolAttribute(GetGlobalValueSymbol(GV), 846a5ad93a10a5435f21090b09edb6b3a7e44967648Chris Lattner MCSA_NoDeadStrip); 847cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner } 848cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner} 849cb05af852f1d346ac07b84c74a930a5cdbd6d427Chris Lattner 850ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the 851ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner/// function pointers, ignoring the init priority. 852ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattnervoid AsmPrinter::EmitXXStructorList(Constant *List) { 853ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner // Should be an array of '{ int, void ()* }' structs. The first value is the 854ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner // init priority, which we ignore. 855ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (!isa<ConstantArray>(List)) return; 856ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner ConstantArray *InitList = cast<ConstantArray>(List); 857ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 858ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ 859ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. 8608de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner 8618de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner if (CS->getOperand(1)->isNullValue()) 8628de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner return; // Found a null terminator, exit printing. 8638de324b59ce81cfb4202c706c96a3140f52e00c0Chris Lattner // Emit the function pointer. 864ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner EmitGlobalConstant(CS->getOperand(1)); 865ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner } 866ed13893ff729bc3b91697f6d80a3ba303782efccChris Lattner} 8673b4fd32a41a90ea67fd09a020d480c20e9c40dafChris Lattner 868f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey//===--------------------------------------------------------------------===// 869f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey// Emission and print routines 870f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey// 871f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 872f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt8 - Emit a byte directive and value. 873f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 874f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt8(int Value) const { 8755eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 1, 0/*addrspace*/); 876f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 877f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 878f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt16 - Emit a short directive and value. 879f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 880f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt16(int Value) const { 8815eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 2, 0/*addrspace*/); 882f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 883f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 884f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt32 - Emit a long directive and value. 885f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 886f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt32(int Value) const { 8875eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 4, 0/*addrspace*/); 888f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 889f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 890f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// EmitInt64 - Emit a long long directive and value. 891f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey/// 892f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskeyvoid AsmPrinter::EmitInt64(uint64_t Value) const { 8935eaa54e210256a939f15e918303197916c992aeeChris Lattner OutStreamer.EmitIntValue(Value, 8, 0/*addrspace*/); 894f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey} 895f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 8960d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner/// EmitLabelDifference - Emit something like ".long Hi-Lo" where the size 8970d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner/// in bytes of the directive is specified by Size and Hi/Lo specify the 8980d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner/// labels. This implicitly uses .set if it is available. 8990d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattnervoid AsmPrinter::EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, 9000d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner unsigned Size) const { 9010d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner // Get the Hi-Lo expression. 9020d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner const MCExpr *Diff = 9030d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(Hi, OutContext), 9040d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner MCSymbolRefExpr::Create(Lo, OutContext), 9050d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner OutContext); 9060d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner 9070d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner if (!MAI->hasSetDirective()) { 9080d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner OutStreamer.EmitValue(Diff, Size, 0/*AddrSpace*/); 9090d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner return; 9100d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner } 9110d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner 9120d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner // Otherwise, emit with .set (aka assignment). 9130d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner MCSymbol *SetLabel = 91498cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner OutContext.GetOrCreateTemporarySymbol(Twine(MAI->getPrivateGlobalPrefix()) + 91598cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner "set" + Twine(SetCounter++)); 9160d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner OutStreamer.EmitAssignment(SetLabel, Diff); 9176cde3e6e993126df756e3be5b9ef43540b904644Chris Lattner OutStreamer.EmitSymbolValue(SetLabel, Size, 0/*AddrSpace*/); 9180d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner} 9190d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner 9200d50c7620d92762eaa5c9dedd07c94f5a6a19935Chris Lattner 921f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey//===----------------------------------------------------------------------===// 922f1cdea1d021068f5c9e118d68321ce28fcea63faJim Laskey 9233a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// EmitAlignment - Emit an alignment directive to the specified power of 9243a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// two boundary. For example, if you pass in 3 here, you will get an 8 9253a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// byte alignment. If a global value is specified, and if that global has 9263a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// an explicit alignment requested, it will unconditionally override the 9273a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// alignment request. However, if ForcedAlignBits is specified, this value 9283a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// has final say: the ultimate alignment will be the max of ForcedAlignBits 9293a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// and the alignment computed with NumBits and the global. 9303a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// 9313a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// The algorithm is: 9323a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// Align = NumBits; 9333a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// if (GV && GV->hasalignment) Align = GV->getalignment(); 9343a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// Align = std::max(Align, ForcedAlignBits); 9353a4205367dc845d4cd804b47e061f8281777c9daChris Lattner// 9363a4205367dc845d4cd804b47e061f8281777c9daChris Lattnervoid AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV, 93705548eb174dd694b651de334b73197a62e5071f1Evan Cheng unsigned ForcedAlignBits, 93805548eb174dd694b651de334b73197a62e5071f1Evan Cheng bool UseFillExpr) const { 93900d56b96e599acbc4f895e86e17029ae7c45f142Dale Johannesen if (GV && GV->getAlignment()) 9403a4205367dc845d4cd804b47e061f8281777c9daChris Lattner NumBits = Log2_32(GV->getAlignment()); 9413a4205367dc845d4cd804b47e061f8281777c9daChris Lattner NumBits = std::max(NumBits, ForcedAlignBits); 9423a4205367dc845d4cd804b47e061f8281777c9daChris Lattner 9432a21c6e86101c857d683e7bdefb775654ccab7e3Chris Lattner if (NumBits == 0) return; // No need to emit alignment. 944663c2d2580e6e9b2435785c7e5a2de18758860a3Chris Lattner 945dabf07c70a5e13a4560d75667fa5c7db28921a92Chris Lattner if (getCurrentSection()->getKind().isText()) 9462cce3712fafb2e72e144414377cd48f5ab95a5aeChris Lattner OutStreamer.EmitCodeAlignment(1 << NumBits); 9472cce3712fafb2e72e144414377cd48f5ab95a5aeChris Lattner else 9482cce3712fafb2e72e144414377cd48f5ab95a5aeChris Lattner OutStreamer.EmitValueToAlignment(1 << NumBits, 0, 1, 0); 949bfddc2030a7e67b9e0c42276525d6932375ff261Chris Lattner} 950a5bb59f85613e8ce481351803e7388f5ab466e72David Greene 95152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner/// LowerConstant - Lower the specified LLVM Constant to an MCExpr. 95252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner/// 95352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattnerstatic const MCExpr *LowerConstant(const Constant *CV, AsmPrinter &AP) { 95452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner MCContext &Ctx = AP.OutContext; 955fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 95652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (CV->isNullValue() || isa<UndefValue>(CV)) 95752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(0, Ctx); 95852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 95952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) 96052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(CI->getZExtValue(), Ctx); 961fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 96252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) 96352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCSymbolRefExpr::Create(AP.GetGlobalValueSymbol(GV), Ctx); 96452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) 96552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx); 966fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 967fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV); 968fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner if (CE == 0) { 96952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner llvm_unreachable("Unknown constant value to lower!"); 97052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCConstantExpr::Create(0, Ctx); 971fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 972fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 973fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner switch (CE->getOpcode()) { 974618f17702d09795279717827eeb06632d6ef49e4Dan Gohman default: 975618f17702d09795279717827eeb06632d6ef49e4Dan Gohman // If the code isn't optimized, there may be outstanding folding 976618f17702d09795279717827eeb06632d6ef49e4Dan Gohman // opportunities. Attempt to fold the expression using TargetData as a 977618f17702d09795279717827eeb06632d6ef49e4Dan Gohman // last resort before giving up. 97854e72eca0c5d012546fcc6d1fdac7ee56c90686cDan Gohman if (Constant *C = 97954e72eca0c5d012546fcc6d1fdac7ee56c90686cDan Gohman ConstantFoldConstantExpression(CE, AP.TM.getTargetData())) 98054e72eca0c5d012546fcc6d1fdac7ee56c90686cDan Gohman if (C != CE) 98154e72eca0c5d012546fcc6d1fdac7ee56c90686cDan Gohman return LowerConstant(C, AP); 982618f17702d09795279717827eeb06632d6ef49e4Dan Gohman#ifndef NDEBUG 983618f17702d09795279717827eeb06632d6ef49e4Dan Gohman CE->dump(); 984618f17702d09795279717827eeb06632d6ef49e4Dan Gohman#endif 985618f17702d09795279717827eeb06632d6ef49e4Dan Gohman llvm_unreachable("FIXME: Don't support this constant expr"); 986fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::GetElementPtr: { 98752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 98852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Generate a symbolic expression for the byte address 98952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const Constant *PtrVal = CE->getOperand(0); 99052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner SmallVector<Value*, 8> IdxVec(CE->op_begin()+1, CE->op_end()); 99152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner int64_t Offset = TD.getIndexedOffset(PtrVal->getType(), &IdxVec[0], 99252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner IdxVec.size()); 99352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 99452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *Base = LowerConstant(CE->getOperand(0), AP); 995fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner if (Offset == 0) 99652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return Base; 997fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 998fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Truncate/sext the offset to the pointer size. 99952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (TD.getPointerSizeInBits() != 64) { 100052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner int SExtAmount = 64-TD.getPointerSizeInBits(); 1001fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Offset = (Offset << SExtAmount) >> SExtAmount; 1002a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 1003fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 100452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx), 100552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner Ctx); 1006fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 100752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 100852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Trunc: 100952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // We emit the value and depend on the assembler to truncate the generated 101052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // expression properly. This is important for differences between 101152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // blockaddress labels. Since the two labels are in the same function, it 101252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // is reasonable to treat their delta as a 32-bit value. 101352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // FALL THROUGH. 1014fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::BitCast: 101552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return LowerConstant(CE->getOperand(0), AP); 1016fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 1017fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::IntToPtr: { 101852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 1019fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Handle casts to pointers by changing them into casts to the appropriate 1020fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // integer type. This promotes constant folding and simplifies this code. 1021fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Constant *Op = CE->getOperand(0); 102252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()), 1023fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner false/*ZExt*/); 102452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return LowerConstant(Op, AP); 1025fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 1026fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 1027fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::PtrToInt: { 102852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 1029fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // Support only foldable casts to/from pointers that can be eliminated by 1030fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // changing the pointer to the appropriately sized integer type. 1031fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner Constant *Op = CE->getOperand(0); 1032fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner const Type *Ty = CE->getType(); 103352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 103452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *OpExpr = LowerConstant(Op, AP); 1035fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner 1036fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner // We can emit the pointer value into this slot if the slot is an 103752492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // integer slot equal to the size of the pointer. 103852492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType())) 103952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return OpExpr; 104052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner 104152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Otherwise the pointer is smaller than the resultant integer, mask off 104252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // the high bits so we are sure to get a proper truncation if the input is 104352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // a constant expr. 104452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType()); 104552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx); 104652492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx); 1047fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner } 1048ddc94019916fbe4d3fff915e6002c39c63488a44Chris Lattner 10495938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman // The MC library also has a right-shift operator, but it isn't consistently 10505938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman // signed or unsigned between different targets. 1051fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Add: 1052fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Sub: 10535938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::Mul: 10545938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::SDiv: 10555938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::SRem: 10565938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::Shl: 1057fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::And: 1058fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner case Instruction::Or: 105952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Xor: { 106052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *LHS = LowerConstant(CE->getOperand(0), AP); 106152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner const MCExpr *RHS = LowerConstant(CE->getOperand(1), AP); 1062fe0e7ed6b077360dbcc6d9f0bc0a4dfeb77c8e9bChris Lattner switch (CE->getOpcode()) { 106352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner default: llvm_unreachable("Unknown binary operator constant cast expr"); 106452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx); 106552492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx); 10665938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::Mul: return MCBinaryExpr::CreateMul(LHS, RHS, Ctx); 10675938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::SDiv: return MCBinaryExpr::CreateDiv(LHS, RHS, Ctx); 10685938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::SRem: return MCBinaryExpr::CreateMod(LHS, RHS, Ctx); 10695938a3e681ab7612f5921c5ccaca5d2e0851c60fDan Gohman case Instruction::Shl: return MCBinaryExpr::CreateShl(LHS, RHS, Ctx); 107052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx); 107152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Or: return MCBinaryExpr::CreateOr (LHS, RHS, Ctx); 107252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx); 1073a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 107452492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner } 1075a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner } 1076a80ba71efe5be5012128e2db0dd29b024e00105aChris Lattner} 10771b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner 107891093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantArray(const ConstantArray *CA, unsigned AddrSpace, 107991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AsmPrinter &AP) { 108005f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner if (AddrSpace != 0 || !CA->isString()) { 108105f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner // Not a string. Print the values in successive locations 108291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 108391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AP.EmitGlobalConstant(CA->getOperand(i), AddrSpace); 108405f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner return; 108500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 108605f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 108705f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner // Otherwise, it can be emitted as .ascii. 108805f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner SmallVector<char, 128> TmpVec; 108905f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner TmpVec.reserve(CA->getNumOperands()); 109005f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 109105f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner TmpVec.push_back(cast<ConstantInt>(CA->getOperand(i))->getZExtValue()); 109205f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner 109305f845314a67f9c30a67e55ce1e3168ff6732ce8Chris Lattner AP.OutStreamer.EmitBytes(StringRef(TmpVec.data(), TmpVec.size()), AddrSpace); 109400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 109500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 109691093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantVector(const ConstantVector *CV, 109791093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 1098bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) 109991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner AP.EmitGlobalConstant(CV->getOperand(i), AddrSpace); 110000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 110100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 110291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattnerstatic void EmitGlobalConstantStruct(const ConstantStruct *CS, 110391093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 110400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Print the fields in successive locations. Pad to align if needed! 110591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner const TargetData *TD = AP.TM.getTargetData(); 110691093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner unsigned Size = TD->getTypeAllocSize(CS->getType()); 11072dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const StructLayout *Layout = TD->getStructLayout(CS->getType()); 110891093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner uint64_t SizeSoFar = 0; 110991093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) { 1110bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner const Constant *Field = CS->getOperand(i); 111100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 111200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Check if padding is needed and insert one or more 0s. 1113bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner uint64_t FieldSize = TD->getTypeAllocSize(Field->getType()); 11142dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1)) 11152dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner - Layout->getElementOffset(i)) - FieldSize; 11162dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner SizeSoFar += FieldSize + PadSize; 111700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 111800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Now print the actual field value. 1119bcb83e5b6c8e074e73986cb641801ecbedd6e4edChris Lattner AP.EmitGlobalConstant(Field, AddrSpace); 112000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 112100d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // Insert padding - this may include padding to increase the size of the 112200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // current field up to the ABI size (if the struct is not packed) as well 112300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // as padding to ensure that the next field starts at the right offset. 11242dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitZeros(PadSize, AddrSpace); 112500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 11262dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner assert(SizeSoFar == Layout->getSizeInBytes() && 112700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman "Layout of constant struct may be incorrect!"); 112800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 112900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 11302dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattnerstatic void EmitGlobalConstantFP(const ConstantFP *CFP, unsigned AddrSpace, 11312dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AsmPrinter &AP) { 113200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // FP Constants are printed as integer constants to avoid losing 11339ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner // precision. 1134cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isDoubleTy()) { 11352dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 1136d79d9dce47d505369662ae5111dba24f9ccdef68Chris Lattner double Val = CFP->getValueAPF().convertToDouble(); 1137d79d9dce47d505369662ae5111dba24f9ccdef68Chris Lattner AP.OutStreamer.GetCommentOS() << "double " << Val << '\n'; 113809ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner } 113909ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner 11402dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 11412dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 114200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 1143cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 1144cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 1145cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isFloatTy()) { 11462dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 11470fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner float Val = CFP->getValueAPF().convertToFloat(); 11480fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner AP.OutStreamer.GetCommentOS() << "float " << Val << '\n'; 1149a12e9d751b64767a5c41a718da2a91122d5874c4Dan Gohman } 11502dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 11512dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 4, AddrSpace); 115200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 1153cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 1154cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 1155cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (CFP->getType()->isX86_FP80Ty()) { 115600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // all long double variants are printed as hex 115700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // api needed to prevent premature destruction 115809ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner APInt API = CFP->getValueAPF().bitcastToAPInt(); 115909ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner const uint64_t *p = API.getRawData(); 11602dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.VerboseAsm) { 116172b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner // Convert to double so we can print the approximate val as a comment. 116272b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner APFloat DoubleVal = CFP->getValueAPF(); 116372b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner bool ignored; 116472b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 116572b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner &ignored); 11660fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner AP.OutStreamer.GetCommentOS() << "x86_fp80 ~= " 11670fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner << DoubleVal.convertToDouble() << '\n'; 116872b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner } 116972b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner 11702dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.TM.getTargetData()->isBigEndian()) { 11712dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 11722dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 117372b5ebc6be0fcfa36583367bc20afadb2c24d985Chris Lattner } else { 11742dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 11752dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 117600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 11779ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner 11789ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner // Emit the tail padding for the long double. 11792dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const TargetData &TD = *AP.TM.getTargetData(); 11802dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitZeros(TD.getTypeAllocSize(CFP->getType()) - 11812dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner TD.getTypeStoreSize(CFP->getType()), AddrSpace); 118200d448a341175556ebd86af68219f5b90b7145a3Dan Gohman return; 1183cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner } 1184cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner 118509ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner assert(CFP->getType()->isPPC_FP128Ty() && 118609ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner "Floating point constant type not handled"); 118709ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner // All long double variants are printed as hex api needed to prevent 118809ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner // premature destruction. 118909ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner APInt API = CFP->getValueAPF().bitcastToAPInt(); 119009ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner const uint64_t *p = API.getRawData(); 11912dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (AP.TM.getTargetData()->isBigEndian()) { 11922dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 11932dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 11949ceff94447235a2e369d9adfdf57368f57dd3f18Chris Lattner } else { 11952dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 11962dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 119709ce674ce81cfa0de096f19833ae7bc7549d851aChris Lattner } 119800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 119900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 12002dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattnerstatic void EmitGlobalConstantLargeInt(const ConstantInt *CI, 12012dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner unsigned AddrSpace, AsmPrinter &AP) { 12022dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner const TargetData *TD = AP.TM.getTargetData(); 120300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman unsigned BitWidth = CI->getBitWidth(); 120438c2b0a99c6a3f5cdf6ef5a46e4a6826b30acbfbChris Lattner assert((BitWidth & 63) == 0 && "only support multiples of 64-bits"); 120500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 120600d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // We don't expect assemblers to support integer data directives 120700d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // for more than 64 bits, so we emit the data in at most 64-bit 120800d448a341175556ebd86af68219f5b90b7145a3Dan Gohman // quantities at a time. 120900d448a341175556ebd86af68219f5b90b7145a3Dan Gohman const uint64_t *RawData = CI->getValue().getRawData(); 121000d448a341175556ebd86af68219f5b90b7145a3Dan Gohman for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { 12112dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Val = TD->isBigEndian() ? RawData[e - i - 1] : RawData[i]; 12122dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 121300d448a341175556ebd86af68219f5b90b7145a3Dan Gohman } 121400d448a341175556ebd86af68219f5b90b7145a3Dan Gohman} 121500d448a341175556ebd86af68219f5b90b7145a3Dan Gohman 121625045bdcda822d63674e2df7e34016536c5d3fa7Chris Lattner/// EmitGlobalConstant - Print a general LLVM constant to the .s file. 1217c8d7bc850ddf5a5df503a173b0bc0f8c03ffec96Sanjiv Guptavoid AsmPrinter::EmitGlobalConstant(const Constant *CV, unsigned AddrSpace) { 1218043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV)) { 12192dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner uint64_t Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 1220744f579b63987854ac1b3f2f9c8d2659c5b5ee40Bill Wendling if (Size == 0) Size = 1; // An empty "_foo:" followed by a section is undef. 12216449abfbc86310edbbe0b5ffb3fad5c14301307fChris Lattner return OutStreamer.EmitZeros(Size, AddrSpace); 12222dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 12232dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner 12242dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 12252dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner unsigned Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 12262dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner switch (Size) { 12272dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 1: 12282dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 2: 12292dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 4: 12302dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner case 8: 12310fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) 12320fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.GetCommentOS() << format("0x%llx\n", CI->getZExtValue()); 12332dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner OutStreamer.EmitIntValue(CI->getZExtValue(), Size, AddrSpace); 12342dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return; 12352dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner default: 12362dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner EmitGlobalConstantLargeInt(CI, AddrSpace, *this); 12372dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return; 12382dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 12392dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner } 12403cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 124191093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) 124291093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantArray(CVA, AddrSpace, *this); 12433cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 124491093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) 124591093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantStruct(CVS, AddrSpace, *this); 12463cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 124791093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) 12482dd245c469f4d842f2b7af80582fb4769a914b23Chris Lattner return EmitGlobalConstantFP(CFP, AddrSpace, *this); 12493cc3a00570e8263369346cf2eef9a72488326952Chris Lattner 125091093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner if (const ConstantVector *V = dyn_cast<ConstantVector>(CV)) 125191093ecf0fed6f007e08f1a4531cdb6f438672a2Chris Lattner return EmitGlobalConstantVector(V, AddrSpace, *this); 12521b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner 1253b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner if (isa<ConstantPointerNull>(CV)) { 1254b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner unsigned Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 1255b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner OutStreamer.EmitIntValue(0, Size, AddrSpace); 1256b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner return; 1257b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner } 1258b0bedd6ebbbf0b9791291f37da5666dd456cf5b1Chris Lattner 125952492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it 126052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner // thread the streamer with EmitValue. 126152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner OutStreamer.EmitValue(LowerConstant(CV, *this), 126252492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner TM.getTargetData()->getTypeAllocSize(CV->getType()), 126352492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner AddrSpace); 12641b7e2356ace23af872cc7d66cf45c56b10e77c4dChris Lattner} 12650264d1a4777370009176157b76d116b3195e3767Chris Lattner 1266fad86b003a839cef40ec8ce8408322f4913368caChris Lattnervoid AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { 1267d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng // Target doesn't support this yet! 1268c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Target does not support EmitMachineConstantPoolValue"); 1269d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng} 1270d6594ae54cfde4db4d30272192645c0a45fb9902Evan Cheng 12713ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// PrintSpecial - Print information related to the specified machine instr 12723ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// that is independent of the operand, and may be independent of the instr 12733ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// itself. This can be useful for portably encoding the comment character 12743ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// or other bits of target-specific knowledge into the asmstrings. The 12753ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// syntax used is ${:comment}. Targets can override this to add support 12763ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner/// for their own strange codes. 12773e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattnervoid AsmPrinter::PrintSpecial(const MachineInstr *MI, const char *Code) const { 1278bae02cfd46c569bb571a234544fb1bbe19c43b59Chris Lattner if (!strcmp(Code, "private")) { 127933adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getPrivateGlobalPrefix(); 1280bae02cfd46c569bb571a234544fb1bbe19c43b59Chris Lattner } else if (!strcmp(Code, "comment")) { 1281f1c0ae9de5365a578fbdfebe4625fb281b0be592Evan Cheng if (VerboseAsm) 128233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString(); 12833ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } else if (!strcmp(Code, "uid")) { 1284b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner // Comparing the address of MI isn't sufficient, because machineinstrs may 1285b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner // be allocated to the same address across functions. 1286b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner const Function *ThisF = MI->getParent()->getParent()->getFunction(); 1287b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner 1288bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson // If this is a new LastFn instruction, bump the counter. 1289bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson if (LastMI != MI || LastFn != ThisF) { 1290b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner ++Counter; 1291b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner LastMI = MI; 1292bd58edf59128d2acb5ae48c76ef8a108fd587db2Owen Anderson LastFn = ThisF; 1293b6a24bfa9550e5561da3091f7e5132575bf5a19eChris Lattner } 12943ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner O << Counter; 12953ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } else { 12967d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin std::string msg; 12977d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin raw_string_ostream Msg(msg); 12987d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin Msg << "Unknown special formatter '" << Code 1299e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "' for machine instr: " << *MI; 13007d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error(Msg.str()); 13013ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner } 13023ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner} 13033ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner 1304cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis/// processDebugLoc - Processes the debug information of each machine 1305cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis/// instruction's DebugLoc. 1306af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patelvoid AsmPrinter::processDebugLoc(const MachineInstr *MI, 1307af0e2726835e096e32c30c1b88cc7a6232a6ef69Devang Patel bool BeforePrintingInsn) { 130853bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (!MAI || !DW || !MAI->doesSupportDebugInformation() 130953bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel || !DW->ShouldEmitDwarfDebug()) 1310d250329291dd9fe0d5f0e72e6cf1e287558a7cbaChris Lattner return; 1311b0fdedb3fd123a47e7deca75d1e6f7d64218b07aDevang Patel DebugLoc DL = MI->getDebugLoc(); 131253bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel if (DL.isUnknown()) 131353bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel return; 13146b61f5816e22ac7f7e009aaf3e11ccce7cfeb085Devang Patel DILocation CurDLT = MF->getDILocation(DL); 13153c91b05d2b1751b9e4e21fd958d358ec463dcd3cDevang Patel if (!CurDLT.getScope().Verify()) 131653bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel return; 131753bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel 1318043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner if (!BeforePrintingInsn) { 131953bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel // After printing instruction 132053bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel DW->EndScope(MI); 1321043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner } else if (CurDLT.getNode() != PrevDLT) { 1322c608784dc8a668abbb96e7a471e6341c1fda669fChris Lattner MCSymbol *L = DW->RecordSourceLine(CurDLT.getLineNumber(), 1323c608784dc8a668abbb96e7a471e6341c1fda669fChris Lattner CurDLT.getColumnNumber(), 1324c608784dc8a668abbb96e7a471e6341c1fda669fChris Lattner CurDLT.getScope().getNode()); 1325043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner DW->BeginScope(MI, L); 1326043c4e5c1d012c8131c7f2fa27a4def32740c42fChris Lattner PrevDLT = CurDLT.getNode(); 1327cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis } 1328cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis} 13293ce9b67e0c0f171c6d09c19407930ce6989f1b9dChris Lattner 133053bb5c95afe4ff2627cac513221af2e4e7c5d2e3Devang Patel 13310264d1a4777370009176157b76d116b3195e3767Chris Lattner/// printInlineAsm - This method formats and prints the specified machine 13320264d1a4777370009176157b76d116b3195e3767Chris Lattner/// instruction that is an inline asm. 13330264d1a4777370009176157b76d116b3195e3767Chris Lattnervoid AsmPrinter::printInlineAsm(const MachineInstr *MI) const { 1334f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner unsigned NumOperands = MI->getNumOperands(); 1335f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner 1336f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner // Count the number of register definitions. 1337f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner unsigned NumDefs = 0; 1338d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef(); 133967942f5dc30be1810f983aba8c94c49ca44e8634Chris Lattner ++NumDefs) 1340f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner assert(NumDefs != NumOperands-1 && "No asm string?"); 1341f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner 1342d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman assert(MI->getOperand(NumDefs).isSymbol() && "No asm string?"); 13436609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 13446609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Disassemble the AsmStr, printing out the literal pieces, the operands, etc. 1345f2b67cff040d1eb3229f7929d0ec7a5e016a7a57Chris Lattner const char *AsmStr = MI->getOperand(NumDefs).getSymbolName(); 13466609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 134740c57860dad429d3c938ed5f918c2c66f3b5fa72Dan Gohman O << '\t'; 134840c57860dad429d3c938ed5f918c2c66f3b5fa72Dan Gohman 1349ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // If this asmstr is empty, just print the #APP/#NOAPP markers. 1350ba2a0b960ea4c73d0f81557f63ae2ea126e08905Dale Johannesen // These are useful to see where empty asm's wound up. 1351f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner if (AsmStr[0] == 0) { 135233adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmStart() << "\n\t"; 135333adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmEnd() << '\n'; 1354f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner return; 1355f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner } 1356f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner 135733adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner O << MAI->getCommentString() << MAI->getInlineAsmStart() << "\n\t"; 1358f26f5dde14dddb7540d4d8024ecdd7f5a8390b39Chris Lattner 1359eb9a42c90bf7e21ad8544315a65f86b668cc0277Bill Wendling // The variant of the current asmprinter. 136033adcfb4d217f5f23d9bde8ba02b8e48f9605fc5Chris Lattner int AsmPrinterVariant = MAI->getAssemblerDialect(); 1361eb9a42c90bf7e21ad8544315a65f86b668cc0277Bill Wendling 13626609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner int CurVariant = -1; // The number of the {.|.|.} region we are in. 13636609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *LastEmitted = AsmStr; // One past the last character emitted. 13642cc2f66c25d9576743026688fdae5ed402726532Chris Lattner 13656609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner while (*LastEmitted) { 13666609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner switch (*LastEmitted) { 13676609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner default: { 13686609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Not a special case, emit the string section literally. 13696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *LiteralEnd = LastEmitted+1; 13706609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && 13711c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') 13726609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LiteralEnd; 13736609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 13746609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner O.write(LastEmitted, LiteralEnd-LastEmitted); 13756609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner LastEmitted = LiteralEnd; 13766609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 13776609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 13781c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner case '\n': 13791c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner ++LastEmitted; // Consume newline character. 1380d19a53ba1d4629f69821f37ca824c65e6df8e8f9Dan Gohman O << '\n'; // Indent code with newline. 13811c05997bd8d8b3e97c9a5384f8197d0348e237a3Chris Lattner break; 13826609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner case '$': { 13836609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '$' character. 1384faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner bool Done = true; 1385faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner 1386faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner // Handle escapes. 1387faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner switch (*LastEmitted) { 1388faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner default: Done = false; break; 1389faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '$': // $$ -> $ 13906609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 13916609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner O << '$'; 13926609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume second '$' character. 13936609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 1394faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '(': // $( -> same as GCC's { character. 1395faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // Consume '(' character. 1396faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner if (CurVariant != -1) { 13977d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Nested variants found in inline asm string: '" 13987d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 1399faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner } 1400faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner CurVariant = 0; // We're in the first variant now. 1401faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 1402faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case '|': 1403faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // consume '|' character. 14048b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen if (CurVariant == -1) 14058b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen O << '|'; // this is gcc's behavior for | outside a variant 14068b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen else 14078b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen ++CurVariant; // We're in the next variant. 1408faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 1409faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner case ')': // $) -> same as GCC's } char. 1410faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner ++LastEmitted; // consume ')' character. 14118b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen if (CurVariant == -1) 14128b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen O << '}'; // this is gcc's behavior for } outside a variant 14138b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen else 14148b1e0549389e4c360ac95f50da95d5009553b447Dale Johannesen CurVariant = -1; 1415faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner break; 14166609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1417faf1daeb92bf4db4a6a68d296e24a6e2a4768022Chris Lattner if (Done) break; 14186609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 14196609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner bool HasCurlyBraces = false; 14206609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (*LastEmitted == '{') { // ${variable} 14216609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '{' character. 14226609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner HasCurlyBraces = true; 14236609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 14246609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 14253e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // If we have ${:foo}, then this is not a real operand reference, it is a 14263e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // "magic" string reference, just like in .td files. Arrange to call 14273e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner // PrintSpecial. 14283e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner if (HasCurlyBraces && *LastEmitted == ':') { 14293e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner ++LastEmitted; 14303e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner const char *StrStart = LastEmitted; 14313e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner const char *StrEnd = strchr(StrStart, '}'); 14323e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner if (StrEnd == 0) { 14337d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Unterminated ${:foo} operand in inline asm string: '" 14347d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 14353e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner } 14363e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner 14373e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner std::string Val(StrStart, StrEnd); 14383e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner PrintSpecial(MI, Val.c_str()); 14393e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner LastEmitted = StrEnd+1; 14403e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner break; 14413e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner } 14423e0cc2634e861b789850b5103efcc8898bf14c4cChris Lattner 14436609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner const char *IDStart = LastEmitted; 14446609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner char *IDEnd; 1445fad2912522a4c97128d8afcc2f40ca0e39287ddbChris Lattner errno = 0; 14466609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner long Val = strtol(IDStart, &IDEnd, 10); // We only accept numbers for IDs. 14476609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (!isdigit(*IDStart) || (Val == 0 && errno == EINVAL)) { 14487d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad $ operand number in inline asm string: '" 14497d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 14506609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 14516609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner LastEmitted = IDEnd; 14526609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1453a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner char Modifier[2] = { 0, 0 }; 1454a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 14556609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (HasCurlyBraces) { 1456a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner // If we have curly braces, check for a modifier character. This 1457a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm. 1458a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner if (*LastEmitted == ':') { 1459a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner ++LastEmitted; // Consume ':' character. 1460a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner if (*LastEmitted == 0) { 14617d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad ${:} expression in inline asm string: '" 14627d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 1463a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner } 1464a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 1465a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner Modifier[0] = *LastEmitted; 1466a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner ++LastEmitted; // Consume modifier character. 1467a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner } 1468a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner 14696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if (*LastEmitted != '}') { 14707d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Bad ${} expression in inline asm string: '" 14717d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 14726609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 14736609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner ++LastEmitted; // Consume '}' character. 14746609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 14756609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 14766609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner if ((unsigned)Val >= NumOperands-1) { 14777d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error("Invalid $ operand number in inline asm string: '" 14787d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin + std::string(AsmStr) + "'"); 14796609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 14806609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1481c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Okay, we finally have a value number. Ask the target to print this 14826609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // operand! 1483c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner if (CurVariant == -1 || CurVariant == AsmPrinterVariant) { 1484c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner unsigned OpNo = 1; 1485fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1486fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner bool Error = false; 1487fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1488c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner // Scan to find the machine operand number for the operand. 1489daf6bc6347b4785102611bdf21c512e8a7678cceChris Lattner for (; Val; --Val) { 1490fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner if (OpNo >= MI->getNumOperands()) break; 14919e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned OpFlags = MI->getOperand(OpNo).getImm(); 1492697cbbfb00c318f98d6eb51945f077e2bfe8781eEvan Cheng OpNo += InlineAsm::getNumOperandRegisters(OpFlags) + 1; 1493daf6bc6347b4785102611bdf21c512e8a7678cceChris Lattner } 1494fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 1495fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner if (OpNo >= MI->getNumOperands()) { 1496fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner Error = true; 1497dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner } else { 14989e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned OpFlags = MI->getOperand(OpNo).getImm(); 1499fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner ++OpNo; // Skip over the ID number. 1500fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner 150110b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner if (Modifier[0] == 'l') // labels are target independent 1502f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner O << *MI->getOperand(OpNo).getMBB()->getSymbol(OutContext); 1503eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen else { 1504eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen AsmPrinter *AP = const_cast<AsmPrinter*>(this); 150586b49f8e2de796cb46c7c8b6a4c4900533fd53f4Dale Johannesen if ((OpFlags & 7) == 4) { 1506eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Error = AP->PrintAsmMemoryOperand(MI, OpNo, AsmPrinterVariant, 1507eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Modifier[0] ? Modifier : 0); 1508eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } else { 1509eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Error = AP->PrintAsmOperand(MI, OpNo, AsmPrinterVariant, 1510eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen Modifier[0] ? Modifier : 0); 1511eb57ea7ea2378b77bc995371c1888193b960cd03Dale Johannesen } 1512fd561cded3cbaec1a4bdfae0703b4be4ea4092f3Chris Lattner } 1513dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner } 1514dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner if (Error) { 15157d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin std::string msg; 15167d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin raw_string_ostream Msg(msg); 151710b318bcb39218d2ed525e4862c854bc8d1baf63Chris Lattner Msg << "Invalid operand found in inline asm: '" << AsmStr << "'\n"; 15187d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin MI->print(Msg); 15197d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin llvm_report_error(Msg.str()); 15206609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 1521c3a9f8d31ce93ba384bd2bbdd55c757b06600a15Chris Lattner } 15226609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner break; 15236609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 15246609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 15256609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner } 15268e089a9e4d6b7aa2b3968c38644f926f60a7c670Chris Lattner O << "\n\t" << MAI->getCommentString() << MAI->getInlineAsmEnd(); 15278e089a9e4d6b7aa2b3968c38644f926f60a7c670Chris Lattner OutStreamer.AddBlankLine(); 15286609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner} 15296609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner 1530da47e6e0d003c873da960361549e57ee4617c301Evan Cheng/// printImplicitDef - This method prints the specified machine instruction 1531da47e6e0d003c873da960361549e57ee4617c301Evan Cheng/// that is an implicit def. 1532da47e6e0d003c873da960361549e57ee4617c301Evan Chengvoid AsmPrinter::printImplicitDef(const MachineInstr *MI) const { 1533c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner if (!VerboseAsm) return; 1534c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O.PadToColumn(MAI->getCommentColumn()); 1535c5ea263a23f4f15587e35c9cb07cf72a9fba7613Chris Lattner O << MAI->getCommentString() << " implicit-def: " 15368e089a9e4d6b7aa2b3968c38644f926f60a7c670Chris Lattner << TRI->getName(MI->getOperand(0).getReg()); 15378e089a9e4d6b7aa2b3968c38644f926f60a7c670Chris Lattner OutStreamer.AddBlankLine(); 1538da47e6e0d003c873da960361549e57ee4617c301Evan Cheng} 1539da47e6e0d003c873da960361549e57ee4617c301Evan Cheng 1540ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesenvoid AsmPrinter::printKill(const MachineInstr *MI) const { 1541ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen if (!VerboseAsm) return; 1542ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O.PadToColumn(MAI->getCommentColumn()); 1543ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O << MAI->getCommentString() << " kill:"; 1544ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen for (unsigned n = 0, e = MI->getNumOperands(); n != e; ++n) { 1545ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen const MachineOperand &op = MI->getOperand(n); 1546ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen assert(op.isReg() && "KILL instruction must have only register operands"); 1547ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen O << ' ' << TRI->getName(op.getReg()) << (op.isDef() ? "<def>" : "<kill>"); 1548ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen } 15498e089a9e4d6b7aa2b3968c38644f926f60a7c670Chris Lattner OutStreamer.AddBlankLine(); 1550ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen} 1551ad68264f590f05db3731a452fc91dc22bc75167dJakob Stoklund Olesen 15521ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey/// printLabel - This method prints a local label used by debug and 15531ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey/// exception handling tables. 1554f64159c8402ef17d14b5f7555378b2c321a4a5abChris Lattnervoid AsmPrinter::printLabelInst(const MachineInstr *MI) const { 1555b2cc1a39f79742320ee6ba126d9eec4d6770dee7Chris Lattner MCSymbol *Sym = 155698cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner OutContext.GetOrCreateTemporarySymbol(Twine(MAI->getPrivateGlobalPrefix()) + 1557b2cc1a39f79742320ee6ba126d9eec4d6770dee7Chris Lattner "label" + Twine(MI->getOperand(0).getImm())); 1558b2cc1a39f79742320ee6ba126d9eec4d6770dee7Chris Lattner OutStreamer.EmitLabel(Sym); 15591ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey} 15601ee29257428960fede862fcfdbe80d5d007927e9Jim Laskey 15611b08bbca5592351a940bcd164bdec724ee954326Evan Chengvoid AsmPrinter::printLabel(unsigned Id) const { 1562b2cc1a39f79742320ee6ba126d9eec4d6770dee7Chris Lattner MCSymbol *Sym = 156398cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner OutContext.GetOrCreateTemporarySymbol(Twine(MAI->getPrivateGlobalPrefix()) + 156498cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner "label" + Twine(Id)); 1565b2cc1a39f79742320ee6ba126d9eec4d6770dee7Chris Lattner OutStreamer.EmitLabel(Sym); 15661b08bbca5592351a940bcd164bdec724ee954326Evan Cheng} 15671b08bbca5592351a940bcd164bdec724ee954326Evan Cheng 15686609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner/// PrintAsmOperand - Print the specified operand of MI, an INLINEASM 15696609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner/// instruction, using the specified assembler variant. Targets should 1570cf0b76649be4eea33aba783d4154ea338b7cbbc2Dale Johannesen/// override this to format as appropriate. 15716609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattnerbool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 1572a36cb0a6b110f1ac9a9388019febb64620a124b9Chris Lattner unsigned AsmVariant, const char *ExtraCode) { 15736609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner // Target doesn't support this yet! 15746609913b7d0ad13058d4ffffb17fb8d8078799efChris Lattner return true; 15750264d1a4777370009176157b76d116b3195e3767Chris Lattner} 1576dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner 1577dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattnerbool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 1578dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner unsigned AsmVariant, 1579dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner const char *ExtraCode) { 1580dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner // Target doesn't support this yet! 1581dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner return true; 1582dd26033002b1b4c569df84ac947828c0fc02f6baChris Lattner} 158337efe6764568a3829fee26aba532283131d1a104Nate Begeman 1584951755445821b92c3dc38f32b5c36e9875fa4318Chris LattnerMCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const { 1585951755445821b92c3dc38f32b5c36e9875fa4318Chris Lattner return GetBlockAddressSymbol(BA->getFunction(), BA->getBasicBlock()); 15868c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman} 15878c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 15888c2b52552c90f39e4b2fed43e309e599e742b6acDan GohmanMCSymbol *AsmPrinter::GetBlockAddressSymbol(const Function *F, 1589951755445821b92c3dc38f32b5c36e9875fa4318Chris Lattner const BasicBlock *BB) const { 15908c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman assert(BB->hasName() && 15918c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman "Address of anonymous basic block not supported yet!"); 15928c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 1593568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // This code must use the function name itself, and not the function number, 1594568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // since it must be possible to generate the label name from within other 1595568a3be545dd1ad256af69549d9b95df474bfd8fDan Gohman // functions. 15962f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner SmallString<60> FnName; 15972f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mang->getNameWithPrefix(FnName, F, false); 15988c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 15992f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner // FIXME: THIS IS BROKEN IF THE LLVM BASIC BLOCK DOESN'T HAVE A NAME! 16004813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner SmallString<60> NameResult; 16012f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mang->getNameWithPrefix(NameResult, 16022f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner StringRef("BA") + Twine((unsigned)FnName.size()) + 1603951755445821b92c3dc38f32b5c36e9875fa4318Chris Lattner "_" + FnName.str() + "_" + BB->getName(), 16042f8cc26be403262703ba00658d45e5adf7bdb514Chris Lattner Mangler::Private); 16054813035b726e7f0a3fd17bec437185fc72a50988Chris Lattner 160698cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateTemporarySymbol(NameResult.str()); 16078c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman} 16088c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 16093924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner/// GetCPISymbol - Return the symbol for the specified constant pool entry. 16103924868a957d5a6d468b61741cbb7db77324d1f6Chris LattnerMCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { 161198cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateTemporarySymbol 161298cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner (Twine(MAI->getPrivateGlobalPrefix()) + "CPI" + Twine(getFunctionNumber()) 161398cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner + "_" + Twine(CPID)); 16143924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner} 16153924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner 16163924868a957d5a6d468b61741cbb7db77324d1f6Chris Lattner/// GetJTISymbol - Return the symbol for the specified jump table entry. 16173924868a957d5a6d468b61741cbb7db77324d1f6Chris LattnerMCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { 1618589c6f620e8dcf3d59af1ae0e15372c934647c82Chris Lattner return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate); 16197cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner} 16207cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner 1621798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner/// GetJTSetSymbol - Return the symbol for the specified jump table .set 1622798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner/// FIXME: privatize to AsmPrinter. 1623798d1256595dcc0f5d4423572f856d239f7de0e6Chris LattnerMCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const { 162498cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateTemporarySymbol 162598cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner (Twine(MAI->getPrivateGlobalPrefix()) + Twine(getFunctionNumber()) + "_" + 162698cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner Twine(UID) + "_set_" + Twine(MBBID)); 1627798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner} 1628798d1256595dcc0f5d4423572f856d239f7de0e6Chris Lattner 16296b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// GetGlobalValueSymbol - Return the MCSymbol for the specified global 16306b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// value. 16316b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris LattnerMCSymbol *AsmPrinter::GetGlobalValueSymbol(const GlobalValue *GV) const { 16326b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner SmallString<60> NameStr; 16336b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner Mang->getNameWithPrefix(NameStr, GV, false); 163498cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner 163598cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner if (!GV->hasPrivateLinkage()) 163698cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 163798cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateTemporarySymbol(NameStr.str()); 16386b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner} 16396b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner 16407a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner/// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with 1641d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner/// global value name as its base, with the specified suffix, and where the 16427a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner/// symbol is forced to have private linkage if ForcePrivate is true. 16437a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris LattnerMCSymbol *AsmPrinter::GetSymbolWithGlobalValueBase(const GlobalValue *GV, 16447a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner StringRef Suffix, 16457a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner bool ForcePrivate) const { 1646d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner SmallString<60> NameStr; 16477a2ba94d03b43f41b54872dacd7b2250dde4c7bdChris Lattner Mang->getNameWithPrefix(NameStr, GV, ForcePrivate); 1648d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner NameStr.append(Suffix.begin(), Suffix.end()); 164998cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner if (!GV->hasPrivateLinkage() && !ForcePrivate) 165098cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 165198cdab53c302a2d6686fa428c0e896b1fb195311Chris Lattner return OutContext.GetOrCreateTemporarySymbol(NameStr.str()); 1652d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner} 1653d588b97cc9acf778282ab10efa4f298cead1215aChris Lattner 16546b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// GetExternalSymbolSymbol - Return the MCSymbol for the specified 16556b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner/// ExternalSymbol. 16566b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris LattnerMCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const { 16576b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner SmallString<60> NameStr; 16586b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner Mang->getNameWithPrefix(NameStr, Sym); 16596b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner return OutContext.GetOrCreateSymbol(NameStr.str()); 16606b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner} 16616b04edee11c2bb35a48b1c42f867b4ba8cdfff97Chris Lattner 16627cb384dcca3f1ccfc993182ee4b972f7fffc8ffaChris Lattner 1663523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1664523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// PrintParentLoopComment - Print comments about parent loops of this one. 1665523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1666523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner unsigned FunctionNumber) { 1667523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop == 0) return; 1668523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber); 1669523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent(Loop->getLoopDepth()*2) 1670523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << "Parent Loop BB" << FunctionNumber << "_" 1671523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << Loop->getHeader()->getNumber() 1672523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << " Depth=" << Loop->getLoopDepth() << '\n'; 1673523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1674523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1675523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1676523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// PrintChildLoopComment - Print comments about child loops within 1677523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner/// the loop for this basic block, with nesting. 1678523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1679523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner unsigned FunctionNumber) { 1680523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Add child loop information 1681523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner for (MachineLoop::iterator CL = Loop->begin(), E = Loop->end();CL != E; ++CL){ 1682523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent((*CL)->getLoopDepth()*2) 1683523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << "Child Loop BB" << FunctionNumber << "_" 1684523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << (*CL)->getHeader()->getNumber() << " Depth " << (*CL)->getLoopDepth() 1685523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner << '\n'; 1686523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintChildLoopComment(OS, *CL, FunctionNumber); 1687523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner } 1688523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1689523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1690d1ff72b8a797304f146e4293db8c814231ea8cb3Chris Lattner/// PrintBasicBlockLoopComments - Pretty-print comments for basic blocks. 1691523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattnerstatic void PrintBasicBlockLoopComments(const MachineBasicBlock &MBB, 1692523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const MachineLoopInfo *LI, 1693523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const AsmPrinter &AP) { 1694523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Add loop depth information 1695523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner const MachineLoop *Loop = LI->getLoopFor(&MBB); 1696523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop == 0) return; 1697523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1698523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner MachineBasicBlock *Header = Loop->getHeader(); 1699523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner assert(Header && "No header for loop"); 1700523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1701523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // If this block is not a loop header, just print out what is the loop header 1702523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // and return. 1703523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Header != &MBB) { 1704523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner AP.OutStreamer.AddComment(" in Loop: Header=BB" + 1705523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner Twine(AP.getFunctionNumber())+"_" + 1706523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner Twine(Loop->getHeader()->getNumber())+ 1707523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner " Depth="+Twine(Loop->getLoopDepth())); 1708523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner return; 1709523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner } 1710523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1711523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // Otherwise, it is a loop header. Print out information about child and 1712523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner // parent loops. 1713523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner raw_ostream &OS = AP.OutStreamer.GetCommentOS(); 1714523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1715523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber()); 1716523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1717523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "=>"; 1718523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS.indent(Loop->getLoopDepth()*2-2); 1719523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1720523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "This "; 1721523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner if (Loop->empty()) 1722523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "Inner "; 1723523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n'; 1724523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1725523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); 1726523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner} 1727523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 1728523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner 172970a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// EmitBasicBlockStart - This method prints the label for the specified 173070a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// MachineBasicBlock, an alignment (if present) and a comment describing 173170a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner/// it if appropriate. 1732662316c997e4eb8c3fdec6999b3e9da03620847aChris Lattnervoid AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock *MBB) const { 1733b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // Emit an alignment directive for this block, if needed. 173470a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner if (unsigned Align = MBB->getAlignment()) 173570a54c07a0807bf89d1a8b4414e53298c376eb61Chris Lattner EmitAlignment(Log2_32(Align)); 1736fb8075d03f5c87bd57dcc9c5f2304f6b13c55aadEvan Cheng 1737b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // If the block has its address taken, emit a special label to satisfy 1738b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // references to the block. This is done so that we don't need to 1739b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // remember the number of this label, and so that we can make 1740b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // forward references to labels without knowing what their numbers 1741b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // will be. 17428c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman if (MBB->hasAddressTaken()) { 1743213168ba469703a186d060281e587d828878aa75Chris Lattner const BasicBlock *BB = MBB->getBasicBlock(); 17440fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) 17450fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("Address Taken"); 1746213168ba469703a186d060281e587d828878aa75Chris Lattner OutStreamer.EmitLabel(GetBlockAddressSymbol(BB->getParent(), BB)); 17478c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman } 17488c2b52552c90f39e4b2fed43e309e599e742b6acDan Gohman 1749b1cac33856687715bf8db3860ff55ad2f6ca94b5Dan Gohman // Print the main label for the block. 17500a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner if (MBB->pred_empty() || isBlockOnlyReachableByFallthrough(MBB)) { 17510fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) { 17523a9be0ee36fe2143f514d28315f3dc1bda132b2eChris Lattner // NOTE: Want this comment at start of line. 1753e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman O << MAI->getCommentString() << " BB#" << MBB->getNumber() << ':'; 17540fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (const BasicBlock *BB = MBB->getBasicBlock()) 17550fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (BB->hasName()) 17560fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("%" + BB->getName()); 1757d8d0aee26a5a759085bfa9114302e507c8685599Chris Lattner 1758523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintBasicBlockLoopComments(*MBB, LI, *this); 17590fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddBlankLine(); 17600fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner } 1761e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman } else { 17620fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (VerboseAsm) { 17630fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (const BasicBlock *BB = MBB->getBasicBlock()) 17640fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner if (BB->hasName()) 17650fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner OutStreamer.AddComment("%" + BB->getName()); 1766523a508576ee2c31ba58de1ca2fb7ffeebcc4a0bChris Lattner PrintBasicBlockLoopComments(*MBB, LI, *this); 17670fd90fd8d1c2143a763dee509c66a5b3c74088b1Chris Lattner } 1768d8d0aee26a5a759085bfa9114302e507c8685599Chris Lattner 1769f71cb015c1386ff8adc9ef0aa03fc0f0fc4a6e3eChris Lattner OutStreamer.EmitLabel(MBB->getSymbol(OutContext)); 1770e3cc3f3c84abfdf8eb3bd19dfa806ceea49f15d6Dan Gohman } 177137efe6764568a3829fee26aba532283131d1a104Nate Begeman} 177252a51e38dc312aa262b0d771419afe1785f3cb22Nate Begeman 1773be9dfcef82c58063708e039bea3cf972ba41581bChris Lattnervoid AsmPrinter::EmitVisibility(MCSymbol *Sym, unsigned Visibility) const { 1774152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner MCSymbolAttr Attr = MCSA_Invalid; 1775152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner 1776152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner switch (Visibility) { 1777152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner default: break; 1778152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner case GlobalValue::HiddenVisibility: 1779152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner Attr = MAI->getHiddenVisibilityAttr(); 1780152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner break; 1781152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner case GlobalValue::ProtectedVisibility: 1782152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner Attr = MAI->getProtectedVisibilityAttr(); 1783152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner break; 178453d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner } 1785152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner 1786152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner if (Attr != MCSA_Invalid) 1787152a29bfa6fa505182658d046bc75626e10d67c3Chris Lattner OutStreamer.EmitSymbolAttribute(Sym, Attr); 178853d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner} 178953d4d78d9a2c26a67ac8f6e81cc149702103fc2cChris Lattner 17907751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikovvoid AsmPrinter::printOffset(int64_t Offset) const { 17917751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov if (Offset > 0) 17927751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov O << '+' << Offset; 17937751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov else if (Offset < 0) 17947751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov O << Offset; 17957751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov} 17967751ad92daeea5a3502fbc266ae814baec5c03e6Anton Korobeynikov 17970a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner/// isBlockOnlyReachableByFallthough - Return true if the basic block has 17980a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner/// exactly one predecessor and the control transfer mechanism between 17990a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner/// the predecessor and this block is a fall-through. 18000a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattnerbool AsmPrinter::isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) 18010a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner const { 18020a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner // If this is a landing pad, it isn't a fall through. If it has no preds, 18030a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner // then nothing falls through to it. 18040a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner if (MBB->isLandingPad() || MBB->pred_empty()) 18050a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner return false; 18060a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18070a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner // If there isn't exactly one predecessor, it can't be a fall through. 18080a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(), PI2 = PI; 18090a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner ++PI2; 18100a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner if (PI2 != MBB->pred_end()) 18110a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner return false; 18120a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18130a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner // The predecessor has to be immediately before this block. 18140a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner const MachineBasicBlock *Pred = *PI; 18150a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18160a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner if (!Pred->isLayoutSuccessor(MBB)) 18170a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner return false; 18180a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18190a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner // If the block is completely empty, then it definitely does fall through. 18200a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner if (Pred->empty()) 18210a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner return true; 18220a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18230a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner // Otherwise, check the last instruction. 18240a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner const MachineInstr &LastInst = Pred->back(); 18250a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner return !LastInst.getDesc().isBarrier(); 18260a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner} 18270a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18280a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18290a3f39985b3827a02a7ce1ca5e310b68820fd26dChris Lattner 18305eca075b74d62c621b160aa216b4cd50829a2cc7Gordon HenriksenGCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy *S) { 18315eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen if (!S->usesMetadata()) 1832c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen return 0; 1833c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 18345eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen gcp_iterator GCPI = GCMetadataPrinters.find(S); 1835c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen if (GCPI != GCMetadataPrinters.end()) 1836c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen return GCPI->second; 1837c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 18385eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen const char *Name = S->getName().c_str(); 1839c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 1840c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen for (GCMetadataPrinterRegistry::iterator 1841c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen I = GCMetadataPrinterRegistry::begin(), 1842c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen E = GCMetadataPrinterRegistry::end(); I != E; ++I) 1843c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen if (strcmp(Name, I->getName()) == 0) { 18445eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCMetadataPrinter *GMP = I->instantiate(); 18455eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GMP->S = S; 18465eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen GCMetadataPrinters.insert(std::make_pair(S, GMP)); 18475eca075b74d62c621b160aa216b4cd50829a2cc7Gordon Henriksen return GMP; 1848c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen } 1849c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen 185052492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner llvm_report_error("no GCMetadataPrinter registered for GC: " + Twine(Name)); 185152492ac0d03aa86b07ad889b69b0ba38ffec8011Chris Lattner return 0; 1852c317a60c2714a5b90700a11ba646285cb754a5d3Gordon Henriksen} 1853014700c1a8cba203fd21ff129426ba8a426ab244David Greene 1854