Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 1 | //===-- AsmPrinter.cpp - Common AsmPrinter code ---------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file was developed by the LLVM research group and is distributed under |
| 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the AsmPrinter class. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Evan Cheng | 932f022 | 2006-03-03 02:04:29 +0000 | [diff] [blame] | 14 | #include "llvm/CodeGen/AsmPrinter.h" |
Evan Cheng | 246ae0d | 2006-03-01 22:18:09 +0000 | [diff] [blame] | 15 | #include "llvm/Assembly/Writer.h" |
Nate Begeman | 8cfa57b | 2005-12-06 06:18:55 +0000 | [diff] [blame] | 16 | #include "llvm/DerivedTypes.h" |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 17 | #include "llvm/Constants.h" |
Chris Lattner | 450de39 | 2005-11-10 18:36:17 +0000 | [diff] [blame] | 18 | #include "llvm/Module.h" |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 19 | #include "llvm/CodeGen/MachineConstantPool.h" |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 20 | #include "llvm/CodeGen/MachineJumpTableInfo.h" |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 21 | #include "llvm/Support/Mangler.h" |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 22 | #include "llvm/Support/MathExtras.h" |
Owen Anderson | 07000c6 | 2006-05-12 06:33:49 +0000 | [diff] [blame] | 23 | #include "llvm/Target/TargetData.h" |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 24 | #include "llvm/Target/TargetMachine.h" |
Duraid Madina | 2e096c1 | 2005-12-28 06:29:02 +0000 | [diff] [blame] | 25 | #include <iostream> |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 26 | #include <cerrno> |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 27 | using namespace llvm; |
| 28 | |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 29 | AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm) |
| 30 | : FunctionNumber(0), O(o), TM(tm), |
| 31 | CommentString("#"), |
| 32 | GlobalPrefix(""), |
| 33 | PrivateGlobalPrefix("."), |
| 34 | GlobalVarAddrPrefix(""), |
| 35 | GlobalVarAddrSuffix(""), |
| 36 | FunctionAddrPrefix(""), |
| 37 | FunctionAddrSuffix(""), |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 38 | InlineAsmStart("#APP"), |
| 39 | InlineAsmEnd("#NO_APP"), |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 40 | ZeroDirective("\t.zero\t"), |
Jeff Cohen | c6a057b | 2006-05-02 03:46:13 +0000 | [diff] [blame] | 41 | ZeroDirectiveSuffix(0), |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 42 | AsciiDirective("\t.ascii\t"), |
| 43 | AscizDirective("\t.asciz\t"), |
| 44 | Data8bitsDirective("\t.byte\t"), |
| 45 | Data16bitsDirective("\t.short\t"), |
| 46 | Data32bitsDirective("\t.long\t"), |
| 47 | Data64bitsDirective("\t.quad\t"), |
| 48 | AlignDirective("\t.align\t"), |
| 49 | AlignmentIsInBytes(true), |
| 50 | SwitchToSectionDirective("\t.section\t"), |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 51 | TextSectionStartSuffix(""), |
| 52 | DataSectionStartSuffix(""), |
| 53 | SectionEndDirectiveSuffix(0), |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 54 | ConstantPoolSection("\t.section .rodata\n"), |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 55 | JumpTableSection("\t.section .rodata\n"), |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 56 | StaticCtorsSection("\t.section .ctors,\"aw\",@progbits"), |
| 57 | StaticDtorsSection("\t.section .dtors,\"aw\",@progbits"), |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 58 | FourByteConstantSection(0), |
| 59 | EightByteConstantSection(0), |
| 60 | SixteenByteConstantSection(0), |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 61 | LCOMMDirective(0), |
| 62 | COMMDirective("\t.comm\t"), |
| 63 | COMMDirectiveTakesAlignment(true), |
| 64 | HasDotTypeDotSizeDirective(true) { |
| 65 | } |
| 66 | |
| 67 | |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 68 | /// SwitchToTextSection - Switch to the specified text section of the executable |
| 69 | /// if we are not already in it! |
Chris Lattner | ac28fbd | 2005-11-21 07:06:27 +0000 | [diff] [blame] | 70 | /// |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 71 | void AsmPrinter::SwitchToTextSection(const char *NewSection, |
| 72 | const GlobalValue *GV) { |
Chris Lattner | ac28fbd | 2005-11-21 07:06:27 +0000 | [diff] [blame] | 73 | std::string NS; |
Chris Lattner | a7090ae | 2006-05-09 05:24:50 +0000 | [diff] [blame] | 74 | if (GV && GV->hasSection()) |
Chris Lattner | c8d37c6 | 2006-05-09 16:41:59 +0000 | [diff] [blame] | 75 | NS = SwitchToSectionDirective + GV->getSection(); |
Chris Lattner | a7090ae | 2006-05-09 05:24:50 +0000 | [diff] [blame] | 76 | else |
| 77 | NS = NewSection; |
| 78 | |
| 79 | // If we're already in this section, we're done. |
| 80 | if (CurrentSection == NS) return; |
Jeff Cohen | 51b776d | 2006-05-02 03:58:45 +0000 | [diff] [blame] | 81 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 82 | // Close the current section, if applicable. |
| 83 | if (SectionEndDirectiveSuffix && !CurrentSection.empty()) |
| 84 | O << CurrentSection << SectionEndDirectiveSuffix << "\n"; |
Jeff Cohen | 51b776d | 2006-05-02 03:58:45 +0000 | [diff] [blame] | 85 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 86 | CurrentSection = NS; |
| 87 | |
| 88 | if (!CurrentSection.empty()) |
| 89 | O << CurrentSection << TextSectionStartSuffix << '\n'; |
Chris Lattner | ac28fbd | 2005-11-21 07:06:27 +0000 | [diff] [blame] | 90 | } |
| 91 | |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 92 | /// SwitchToTextSection - Switch to the specified text section of the executable |
| 93 | /// if we are not already in it! |
| 94 | /// |
| 95 | void AsmPrinter::SwitchToDataSection(const char *NewSection, |
| 96 | const GlobalValue *GV) { |
| 97 | std::string NS; |
Chris Lattner | b81cb61 | 2006-05-09 05:23:12 +0000 | [diff] [blame] | 98 | if (GV && GV->hasSection()) |
| 99 | NS = SwitchToSectionDirective + GV->getSection(); |
| 100 | else |
| 101 | NS = NewSection; |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 102 | |
Chris Lattner | b81cb61 | 2006-05-09 05:23:12 +0000 | [diff] [blame] | 103 | // If we're already in this section, we're done. |
| 104 | if (CurrentSection == NS) return; |
| 105 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 106 | // Close the current section, if applicable. |
| 107 | if (SectionEndDirectiveSuffix && !CurrentSection.empty()) |
| 108 | O << CurrentSection << SectionEndDirectiveSuffix << "\n"; |
| 109 | |
| 110 | CurrentSection = NS; |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 111 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 112 | if (!CurrentSection.empty()) |
| 113 | O << CurrentSection << DataSectionStartSuffix << '\n'; |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 117 | bool AsmPrinter::doInitialization(Module &M) { |
Chris Lattner | af2bf0a | 2004-08-17 06:06:19 +0000 | [diff] [blame] | 118 | Mang = new Mangler(M, GlobalPrefix); |
Chris Lattner | 2c1b159 | 2006-01-23 23:47:53 +0000 | [diff] [blame] | 119 | |
Chris Lattner | 3e2fa7a | 2006-01-24 04:16:34 +0000 | [diff] [blame] | 120 | if (!M.getModuleInlineAsm().empty()) |
| 121 | O << CommentString << " Start of file scope inline assembly\n" |
| 122 | << M.getModuleInlineAsm() |
| 123 | << "\n" << CommentString << " End of file scope inline assembly\n"; |
Chris Lattner | 2c1b159 | 2006-01-23 23:47:53 +0000 | [diff] [blame] | 124 | |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 125 | SwitchToDataSection("", 0); // Reset back to no section. |
Jim Laskey | b3e789a | 2006-01-26 20:21:46 +0000 | [diff] [blame] | 126 | |
| 127 | if (MachineDebugInfo *DebugInfo = getAnalysisToUpdate<MachineDebugInfo>()) { |
| 128 | DebugInfo->AnalyzeModule(M); |
| 129 | } |
| 130 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 131 | return false; |
| 132 | } |
| 133 | |
| 134 | bool AsmPrinter::doFinalization(Module &M) { |
| 135 | delete Mang; Mang = 0; |
| 136 | return false; |
| 137 | } |
| 138 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 139 | void AsmPrinter::SetupMachineFunction(MachineFunction &MF) { |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 140 | // What's my mangled name? |
Chris Lattner | 450de39 | 2005-11-10 18:36:17 +0000 | [diff] [blame] | 141 | CurrentFnName = Mang->getValueName(MF.getFunction()); |
Chris Lattner | 77bc228 | 2005-11-21 08:13:27 +0000 | [diff] [blame] | 142 | IncrementFunctionNumber(); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 143 | } |
| 144 | |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 145 | /// EmitConstantPool - Print to the current output stream assembly |
| 146 | /// representations of the constants in the constant pool MCP. This is |
| 147 | /// used to print out constants which have been "spilled to memory" by |
| 148 | /// the code generator. |
| 149 | /// |
| 150 | void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) { |
Chris Lattner | fa77d43 | 2006-02-09 04:22:52 +0000 | [diff] [blame] | 151 | const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 152 | if (CP.empty()) return; |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 153 | |
| 154 | // Some targets require 4-, 8-, and 16- byte constant literals to be placed |
| 155 | // in special sections. |
| 156 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > FourByteCPs; |
| 157 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > EightByteCPs; |
| 158 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > SixteenByteCPs; |
| 159 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > OtherCPs; |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 160 | for (unsigned i = 0, e = CP.size(); i != e; ++i) { |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 161 | MachineConstantPoolEntry CPE = CP[i]; |
| 162 | const Constant *CV = CPE.Val; |
| 163 | const Type *Ty = CV->getType(); |
| 164 | if (FourByteConstantSection && |
| 165 | TM.getTargetData()->getTypeSize(Ty) == 4) |
| 166 | FourByteCPs.push_back(std::make_pair(CPE, i)); |
| 167 | else if (EightByteConstantSection && |
| 168 | TM.getTargetData()->getTypeSize(Ty) == 8) |
| 169 | EightByteCPs.push_back(std::make_pair(CPE, i)); |
| 170 | else if (SixteenByteConstantSection && |
| 171 | TM.getTargetData()->getTypeSize(Ty) == 16) |
| 172 | SixteenByteCPs.push_back(std::make_pair(CPE, i)); |
| 173 | else |
| 174 | OtherCPs.push_back(std::make_pair(CPE, i)); |
| 175 | } |
| 176 | |
| 177 | unsigned Alignment = MCP->getConstantPoolAlignment(); |
| 178 | EmitConstantPool(Alignment, FourByteConstantSection, FourByteCPs); |
| 179 | EmitConstantPool(Alignment, EightByteConstantSection, EightByteCPs); |
| 180 | EmitConstantPool(Alignment, SixteenByteConstantSection, SixteenByteCPs); |
| 181 | EmitConstantPool(Alignment, ConstantPoolSection, OtherCPs); |
| 182 | } |
| 183 | |
| 184 | void AsmPrinter::EmitConstantPool(unsigned Alignment, const char *Section, |
| 185 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > &CP) { |
| 186 | if (CP.empty()) return; |
| 187 | |
| 188 | SwitchToDataSection(Section, 0); |
| 189 | EmitAlignment(Alignment); |
| 190 | for (unsigned i = 0, e = CP.size(); i != e; ++i) { |
| 191 | O << PrivateGlobalPrefix << "CPI" << getFunctionNumber() << '_' |
| 192 | << CP[i].second << ":\t\t\t\t\t" << CommentString << " "; |
| 193 | WriteTypeSymbolic(O, CP[i].first.Val->getType(), 0) << '\n'; |
| 194 | EmitGlobalConstant(CP[i].first.Val); |
Chris Lattner | 3029f92 | 2006-02-09 04:46:04 +0000 | [diff] [blame] | 195 | if (i != e-1) { |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 196 | unsigned EntSize = |
| 197 | TM.getTargetData()->getTypeSize(CP[i].first.Val->getType()); |
| 198 | unsigned ValEnd = CP[i].first.Offset + EntSize; |
Chris Lattner | 3029f92 | 2006-02-09 04:46:04 +0000 | [diff] [blame] | 199 | // Emit inter-object padding for alignment. |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 200 | EmitZeros(CP[i+1].first.Offset-ValEnd); |
Chris Lattner | 3029f92 | 2006-02-09 04:46:04 +0000 | [diff] [blame] | 201 | } |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 202 | } |
| 203 | } |
| 204 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 205 | /// EmitJumpTableInfo - Print assembly representations of the jump tables used |
| 206 | /// by the current function to the current output stream. |
| 207 | /// |
| 208 | void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI) { |
| 209 | const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); |
| 210 | if (JT.empty()) return; |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 211 | const TargetData *TD = TM.getTargetData(); |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 212 | |
| 213 | // FIXME: someday we need to handle PIC jump tables |
| 214 | assert((TM.getRelocationModel() == Reloc::Static || |
| 215 | TM.getRelocationModel() == Reloc::DynamicNoPIC) && |
| 216 | "Unhandled relocation model emitting jump table information!"); |
| 217 | |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 218 | SwitchToDataSection(JumpTableSection, 0); |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 219 | EmitAlignment(Log2_32(TD->getPointerAlignment())); |
Chris Lattner | 0c4e678 | 2006-07-15 01:34:12 +0000 | [diff] [blame^] | 220 | |
| 221 | // Pick the directive to use based on the pointer size. FIXME: when we support |
| 222 | // PIC jumptables, this should always use the 32-bit directive for label |
| 223 | // differences. |
| 224 | const char *PtrDataDirective = Data32bitsDirective; |
| 225 | if (TD->getPointerSize() == 8) |
| 226 | PtrDataDirective = Data64bitsDirective; |
| 227 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 228 | for (unsigned i = 0, e = JT.size(); i != e; ++i) { |
| 229 | O << PrivateGlobalPrefix << "JTI" << getFunctionNumber() << '_' << i |
| 230 | << ":\n"; |
| 231 | const std::vector<MachineBasicBlock*> &JTBBs = JT[i].MBBs; |
| 232 | for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { |
Chris Lattner | 0c4e678 | 2006-07-15 01:34:12 +0000 | [diff] [blame^] | 233 | O << PtrDataDirective << ' '; |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 234 | printBasicBlockLabel(JTBBs[ii]); |
| 235 | O << '\n'; |
| 236 | } |
| 237 | } |
| 238 | } |
| 239 | |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 240 | /// EmitSpecialLLVMGlobal - Check to see if the specified global is a |
| 241 | /// special global used by LLVM. If so, emit it and return true, otherwise |
| 242 | /// do nothing and return false. |
| 243 | bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { |
Jim Laskey | 7809811 | 2006-03-07 22:00:35 +0000 | [diff] [blame] | 244 | // Ignore debug and non-emitted data. |
| 245 | if (GV->getSection() == "llvm.metadata") return true; |
| 246 | |
| 247 | if (!GV->hasAppendingLinkage()) return false; |
| 248 | |
| 249 | assert(GV->hasInitializer() && "Not a special LLVM global!"); |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 250 | |
| 251 | if (GV->getName() == "llvm.used") |
| 252 | return true; // No need to emit this at all. |
| 253 | |
Chris Lattner | 5166b82 | 2006-01-12 19:17:23 +0000 | [diff] [blame] | 254 | if (GV->getName() == "llvm.global_ctors" && GV->use_empty()) { |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 255 | SwitchToDataSection(StaticCtorsSection, 0); |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 256 | EmitAlignment(2, 0); |
| 257 | EmitXXStructorList(GV->getInitializer()); |
| 258 | return true; |
| 259 | } |
| 260 | |
Chris Lattner | 5166b82 | 2006-01-12 19:17:23 +0000 | [diff] [blame] | 261 | if (GV->getName() == "llvm.global_dtors" && GV->use_empty()) { |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 262 | SwitchToDataSection(StaticDtorsSection, 0); |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 263 | EmitAlignment(2, 0); |
| 264 | EmitXXStructorList(GV->getInitializer()); |
| 265 | return true; |
| 266 | } |
| 267 | |
| 268 | return false; |
| 269 | } |
| 270 | |
| 271 | /// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the |
| 272 | /// function pointers, ignoring the init priority. |
| 273 | void AsmPrinter::EmitXXStructorList(Constant *List) { |
| 274 | // Should be an array of '{ int, void ()* }' structs. The first value is the |
| 275 | // init priority, which we ignore. |
| 276 | if (!isa<ConstantArray>(List)) return; |
| 277 | ConstantArray *InitList = cast<ConstantArray>(List); |
| 278 | for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) |
| 279 | if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ |
| 280 | if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. |
Chris Lattner | 8de324b | 2005-12-21 01:17:37 +0000 | [diff] [blame] | 281 | |
| 282 | if (CS->getOperand(1)->isNullValue()) |
| 283 | return; // Found a null terminator, exit printing. |
| 284 | // Emit the function pointer. |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 285 | EmitGlobalConstant(CS->getOperand(1)); |
| 286 | } |
| 287 | } |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 288 | |
Chris Lattner | 4d57e0c | 2006-02-05 01:29:18 +0000 | [diff] [blame] | 289 | /// getPreferredAlignmentLog - Return the preferred alignment of the |
| 290 | /// specified global, returned in log form. This includes an explicitly |
| 291 | /// requested alignment (if the global has one). |
| 292 | unsigned AsmPrinter::getPreferredAlignmentLog(const GlobalVariable *GV) const { |
Jim Laskey | 35f8c20 | 2006-06-15 13:10:58 +0000 | [diff] [blame] | 293 | const Type *ElemType = GV->getType()->getElementType(); |
| 294 | unsigned Alignment = TM.getTargetData()->getTypeAlignmentShift(ElemType); |
Chris Lattner | 4d57e0c | 2006-02-05 01:29:18 +0000 | [diff] [blame] | 295 | if (GV->getAlignment() > (1U << Alignment)) |
| 296 | Alignment = Log2_32(GV->getAlignment()); |
| 297 | |
Chris Lattner | 519ea2a | 2006-02-05 01:46:49 +0000 | [diff] [blame] | 298 | if (GV->hasInitializer()) { |
Jim Laskey | d5a932b | 2006-06-15 19:37:14 +0000 | [diff] [blame] | 299 | // Always round up alignment of global doubles to 8 bytes. |
| 300 | if (GV->getType()->getElementType() == Type::DoubleTy && Alignment < 3) |
| 301 | Alignment = 3; |
Chris Lattner | 519ea2a | 2006-02-05 01:46:49 +0000 | [diff] [blame] | 302 | if (Alignment < 4) { |
| 303 | // If the global is not external, see if it is large. If so, give it a |
| 304 | // larger alignment. |
Jim Laskey | 35f8c20 | 2006-06-15 13:10:58 +0000 | [diff] [blame] | 305 | if (TM.getTargetData()->getTypeSize(ElemType) > 128) |
Chris Lattner | 519ea2a | 2006-02-05 01:46:49 +0000 | [diff] [blame] | 306 | Alignment = 4; // 16-byte alignment. |
| 307 | } |
Chris Lattner | 4d57e0c | 2006-02-05 01:29:18 +0000 | [diff] [blame] | 308 | } |
| 309 | return Alignment; |
| 310 | } |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 311 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 312 | // EmitAlignment - Emit an alignment directive to the specified power of two. |
| 313 | void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const { |
Chris Lattner | a1ab72d | 2005-11-14 19:00:06 +0000 | [diff] [blame] | 314 | if (GV && GV->getAlignment()) |
| 315 | NumBits = Log2_32(GV->getAlignment()); |
Chris Lattner | 2a21c6e | 2005-11-10 18:09:27 +0000 | [diff] [blame] | 316 | if (NumBits == 0) return; // No need to emit alignment. |
Chris Lattner | bfddc20 | 2004-08-17 19:14:29 +0000 | [diff] [blame] | 317 | if (AlignmentIsInBytes) NumBits = 1 << NumBits; |
| 318 | O << AlignDirective << NumBits << "\n"; |
| 319 | } |
| 320 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 321 | /// EmitZeros - Emit a block of zeros. |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 322 | /// |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 323 | void AsmPrinter::EmitZeros(uint64_t NumZeros) const { |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 324 | if (NumZeros) { |
Jeff Cohen | c6a057b | 2006-05-02 03:46:13 +0000 | [diff] [blame] | 325 | if (ZeroDirective) { |
| 326 | O << ZeroDirective << NumZeros; |
| 327 | if (ZeroDirectiveSuffix) |
| 328 | O << ZeroDirectiveSuffix; |
| 329 | O << "\n"; |
| 330 | } else { |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 331 | for (; NumZeros; --NumZeros) |
| 332 | O << Data8bitsDirective << "0\n"; |
| 333 | } |
| 334 | } |
| 335 | } |
| 336 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 337 | // Print out the specified constant, without a storage class. Only the |
| 338 | // constants valid in constant expressions can occur here. |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 339 | void AsmPrinter::EmitConstantValueOnly(const Constant *CV) { |
Chris Lattner | bd1d382 | 2004-10-16 18:19:26 +0000 | [diff] [blame] | 340 | if (CV->isNullValue() || isa<UndefValue>(CV)) |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 341 | O << "0"; |
| 342 | else if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) { |
| 343 | assert(CB == ConstantBool::True); |
| 344 | O << "1"; |
| 345 | } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) |
| 346 | if (((CI->getValue() << 32) >> 32) == CI->getValue()) |
| 347 | O << CI->getValue(); |
| 348 | else |
Duraid Madina | 4560657 | 2005-05-15 13:05:48 +0000 | [diff] [blame] | 349 | O << (uint64_t)CI->getValue(); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 350 | else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV)) |
| 351 | O << CI->getValue(); |
Chris Lattner | 450de39 | 2005-11-10 18:36:17 +0000 | [diff] [blame] | 352 | else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) { |
Duraid Madina | 855a519 | 2005-04-02 12:21:51 +0000 | [diff] [blame] | 353 | // This is a constant address for a global variable or function. Use the |
| 354 | // name of the variable or function as the address value, possibly |
| 355 | // decorating it with GlobalVarAddrPrefix/Suffix or |
| 356 | // FunctionAddrPrefix/Suffix (these all default to "" ) |
Chris Lattner | 450de39 | 2005-11-10 18:36:17 +0000 | [diff] [blame] | 357 | if (isa<Function>(GV)) |
| 358 | O << FunctionAddrPrefix << Mang->getValueName(GV) << FunctionAddrSuffix; |
Duraid Madina | 855a519 | 2005-04-02 12:21:51 +0000 | [diff] [blame] | 359 | else |
Chris Lattner | 450de39 | 2005-11-10 18:36:17 +0000 | [diff] [blame] | 360 | O << GlobalVarAddrPrefix << Mang->getValueName(GV) << GlobalVarAddrSuffix; |
Duraid Madina | 855a519 | 2005-04-02 12:21:51 +0000 | [diff] [blame] | 361 | } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 362 | const TargetData *TD = TM.getTargetData(); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 363 | switch(CE->getOpcode()) { |
| 364 | case Instruction::GetElementPtr: { |
| 365 | // generate a symbolic expression for the byte address |
| 366 | const Constant *ptrVal = CE->getOperand(0); |
| 367 | std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end()); |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 368 | if (int64_t Offset = TD->getIndexedOffset(ptrVal->getType(), idxVec)) { |
Chris Lattner | 27e1921 | 2005-02-14 21:40:26 +0000 | [diff] [blame] | 369 | if (Offset) |
| 370 | O << "("; |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 371 | EmitConstantValueOnly(ptrVal); |
Chris Lattner | 27e1921 | 2005-02-14 21:40:26 +0000 | [diff] [blame] | 372 | if (Offset > 0) |
| 373 | O << ") + " << Offset; |
| 374 | else if (Offset < 0) |
| 375 | O << ") - " << -Offset; |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 376 | } else { |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 377 | EmitConstantValueOnly(ptrVal); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 378 | } |
| 379 | break; |
| 380 | } |
| 381 | case Instruction::Cast: { |
| 382 | // Support only non-converting or widening casts for now, that is, ones |
| 383 | // that do not involve a change in value. This assertion is really gross, |
| 384 | // and may not even be a complete check. |
| 385 | Constant *Op = CE->getOperand(0); |
| 386 | const Type *OpTy = Op->getType(), *Ty = CE->getType(); |
| 387 | |
| 388 | // Remember, kids, pointers can be losslessly converted back and forth |
| 389 | // into 32-bit or wider integers, regardless of signedness. :-P |
| 390 | assert(((isa<PointerType>(OpTy) |
| 391 | && (Ty == Type::LongTy || Ty == Type::ULongTy |
| 392 | || Ty == Type::IntTy || Ty == Type::UIntTy)) |
| 393 | || (isa<PointerType>(Ty) |
| 394 | && (OpTy == Type::LongTy || OpTy == Type::ULongTy |
| 395 | || OpTy == Type::IntTy || OpTy == Type::UIntTy)) |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 396 | || (((TD->getTypeSize(Ty) >= TD->getTypeSize(OpTy)) |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 397 | && OpTy->isLosslesslyConvertibleTo(Ty)))) |
| 398 | && "FIXME: Don't yet support this kind of constant cast expr"); |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 399 | EmitConstantValueOnly(Op); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 400 | break; |
| 401 | } |
| 402 | case Instruction::Add: |
| 403 | O << "("; |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 404 | EmitConstantValueOnly(CE->getOperand(0)); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 405 | O << ") + ("; |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 406 | EmitConstantValueOnly(CE->getOperand(1)); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 407 | O << ")"; |
| 408 | break; |
| 409 | default: |
| 410 | assert(0 && "Unsupported operator!"); |
| 411 | } |
| 412 | } else { |
| 413 | assert(0 && "Unknown constant value!"); |
| 414 | } |
| 415 | } |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 416 | |
| 417 | /// toOctal - Convert the low order bits of X into an octal digit. |
| 418 | /// |
| 419 | static inline char toOctal(int X) { |
| 420 | return (X&7)+'0'; |
| 421 | } |
| 422 | |
Chris Lattner | 2980cef | 2005-11-10 18:06:33 +0000 | [diff] [blame] | 423 | /// printAsCString - Print the specified array as a C compatible string, only if |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 424 | /// the predicate isString is true. |
| 425 | /// |
Chris Lattner | 2980cef | 2005-11-10 18:06:33 +0000 | [diff] [blame] | 426 | static void printAsCString(std::ostream &O, const ConstantArray *CVA, |
| 427 | unsigned LastElt) { |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 428 | assert(CVA->isString() && "Array is not string compatible!"); |
| 429 | |
| 430 | O << "\""; |
Chris Lattner | 2980cef | 2005-11-10 18:06:33 +0000 | [diff] [blame] | 431 | for (unsigned i = 0; i != LastElt; ++i) { |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 432 | unsigned char C = |
Chris Lattner | dea18b6 | 2005-01-08 19:59:10 +0000 | [diff] [blame] | 433 | (unsigned char)cast<ConstantInt>(CVA->getOperand(i))->getRawValue(); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 434 | |
| 435 | if (C == '"') { |
| 436 | O << "\\\""; |
| 437 | } else if (C == '\\') { |
| 438 | O << "\\\\"; |
| 439 | } else if (isprint(C)) { |
| 440 | O << C; |
| 441 | } else { |
| 442 | switch(C) { |
| 443 | case '\b': O << "\\b"; break; |
| 444 | case '\f': O << "\\f"; break; |
| 445 | case '\n': O << "\\n"; break; |
| 446 | case '\r': O << "\\r"; break; |
| 447 | case '\t': O << "\\t"; break; |
| 448 | default: |
| 449 | O << '\\'; |
| 450 | O << toOctal(C >> 6); |
| 451 | O << toOctal(C >> 3); |
| 452 | O << toOctal(C >> 0); |
| 453 | break; |
| 454 | } |
| 455 | } |
| 456 | } |
| 457 | O << "\""; |
| 458 | } |
| 459 | |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 460 | /// EmitString - Emit a zero-byte-terminated string constant. |
| 461 | /// |
| 462 | void AsmPrinter::EmitString(const ConstantArray *CVA) const { |
| 463 | unsigned NumElts = CVA->getNumOperands(); |
| 464 | if (AscizDirective && NumElts && |
| 465 | cast<ConstantInt>(CVA->getOperand(NumElts-1))->getRawValue() == 0) { |
| 466 | O << AscizDirective; |
| 467 | printAsCString(O, CVA, NumElts-1); |
| 468 | } else { |
| 469 | O << AsciiDirective; |
| 470 | printAsCString(O, CVA, NumElts); |
| 471 | } |
| 472 | O << "\n"; |
| 473 | } |
| 474 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 475 | /// EmitGlobalConstant - Print a general LLVM constant to the .s file. |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 476 | /// |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 477 | void AsmPrinter::EmitGlobalConstant(const Constant *CV) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 478 | const TargetData *TD = TM.getTargetData(); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 479 | |
Chris Lattner | bd1d382 | 2004-10-16 18:19:26 +0000 | [diff] [blame] | 480 | if (CV->isNullValue() || isa<UndefValue>(CV)) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 481 | EmitZeros(TD->getTypeSize(CV->getType())); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 482 | return; |
| 483 | } else if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) { |
| 484 | if (CVA->isString()) { |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 485 | EmitString(CVA); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 486 | } else { // Not a string. Print the values in successive locations |
| 487 | for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i) |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 488 | EmitGlobalConstant(CVA->getOperand(i)); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 489 | } |
| 490 | return; |
| 491 | } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) { |
| 492 | // Print the fields in successive locations. Pad to align if needed! |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 493 | const StructLayout *cvsLayout = TD->getStructLayout(CVS->getType()); |
Chris Lattner | dea18b6 | 2005-01-08 19:59:10 +0000 | [diff] [blame] | 494 | uint64_t sizeSoFar = 0; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 495 | for (unsigned i = 0, e = CVS->getNumOperands(); i != e; ++i) { |
| 496 | const Constant* field = CVS->getOperand(i); |
| 497 | |
| 498 | // Check if padding is needed and insert one or more 0s. |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 499 | uint64_t fieldSize = TD->getTypeSize(field->getType()); |
Chris Lattner | dea18b6 | 2005-01-08 19:59:10 +0000 | [diff] [blame] | 500 | uint64_t padSize = ((i == e-1? cvsLayout->StructSize |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 501 | : cvsLayout->MemberOffsets[i+1]) |
| 502 | - cvsLayout->MemberOffsets[i]) - fieldSize; |
| 503 | sizeSoFar += fieldSize + padSize; |
| 504 | |
| 505 | // Now print the actual field value |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 506 | EmitGlobalConstant(field); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 507 | |
| 508 | // Insert the field padding unless it's zero bytes... |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 509 | EmitZeros(padSize); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 510 | } |
| 511 | assert(sizeSoFar == cvsLayout->StructSize && |
| 512 | "Layout of constant struct may be incorrect!"); |
| 513 | return; |
| 514 | } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { |
| 515 | // FP Constants are printed as integer constants to avoid losing |
| 516 | // precision... |
| 517 | double Val = CFP->getValue(); |
| 518 | if (CFP->getType() == Type::DoubleTy) { |
Chris Lattner | e85a5a9 | 2004-08-17 06:48:16 +0000 | [diff] [blame] | 519 | if (Data64bitsDirective) |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 520 | O << Data64bitsDirective << DoubleToBits(Val) << "\t" << CommentString |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 521 | << " double value: " << Val << "\n"; |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 522 | else if (TD->isBigEndian()) { |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 523 | O << Data32bitsDirective << unsigned(DoubleToBits(Val) >> 32) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 524 | << "\t" << CommentString << " double most significant word " |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 525 | << Val << "\n"; |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 526 | O << Data32bitsDirective << unsigned(DoubleToBits(Val)) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 527 | << "\t" << CommentString << " double least significant word " |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 528 | << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 529 | } else { |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 530 | O << Data32bitsDirective << unsigned(DoubleToBits(Val)) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 531 | << "\t" << CommentString << " double least significant word " << Val |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 532 | << "\n"; |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 533 | O << Data32bitsDirective << unsigned(DoubleToBits(Val) >> 32) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 534 | << "\t" << CommentString << " double most significant word " << Val |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 535 | << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 536 | } |
| 537 | return; |
| 538 | } else { |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 539 | O << Data32bitsDirective << FloatToBits(Val) << "\t" << CommentString |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 540 | << " float " << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 541 | return; |
| 542 | } |
| 543 | } else if (CV->getType() == Type::ULongTy || CV->getType() == Type::LongTy) { |
| 544 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { |
| 545 | uint64_t Val = CI->getRawValue(); |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 546 | |
Chris Lattner | e85a5a9 | 2004-08-17 06:48:16 +0000 | [diff] [blame] | 547 | if (Data64bitsDirective) |
| 548 | O << Data64bitsDirective << Val << "\n"; |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 549 | else if (TD->isBigEndian()) { |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 550 | O << Data32bitsDirective << unsigned(Val >> 32) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 551 | << "\t" << CommentString << " Double-word most significant word " |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 552 | << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 553 | O << Data32bitsDirective << unsigned(Val) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 554 | << "\t" << CommentString << " Double-word least significant word " |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 555 | << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 556 | } else { |
| 557 | O << Data32bitsDirective << unsigned(Val) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 558 | << "\t" << CommentString << " Double-word least significant word " |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 559 | << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 560 | O << Data32bitsDirective << unsigned(Val >> 32) |
Chris Lattner | f746a7d | 2004-08-18 02:22:55 +0000 | [diff] [blame] | 561 | << "\t" << CommentString << " Double-word most significant word " |
Chris Lattner | 0554fb6 | 2004-08-17 16:27:05 +0000 | [diff] [blame] | 562 | << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 563 | } |
| 564 | return; |
| 565 | } |
Nate Begeman | 8cfa57b | 2005-12-06 06:18:55 +0000 | [diff] [blame] | 566 | } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) { |
| 567 | const PackedType *PTy = CP->getType(); |
| 568 | |
| 569 | for (unsigned I = 0, E = PTy->getNumElements(); I < E; ++I) |
| 570 | EmitGlobalConstant(CP->getOperand(I)); |
| 571 | |
| 572 | return; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 573 | } |
| 574 | |
| 575 | const Type *type = CV->getType(); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 576 | switch (type->getTypeID()) { |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 577 | case Type::BoolTyID: |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 578 | case Type::UByteTyID: case Type::SByteTyID: |
| 579 | O << Data8bitsDirective; |
| 580 | break; |
| 581 | case Type::UShortTyID: case Type::ShortTyID: |
| 582 | O << Data16bitsDirective; |
| 583 | break; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 584 | case Type::PointerTyID: |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 585 | if (TD->getPointerSize() == 8) { |
Evan Cheng | a9767f6 | 2006-06-15 08:10:56 +0000 | [diff] [blame] | 586 | assert(Data64bitsDirective && |
| 587 | "Target cannot handle 64-bit pointer exprs!"); |
Andrew Lenharth | 571c9c3 | 2005-02-04 13:47:16 +0000 | [diff] [blame] | 588 | O << Data64bitsDirective; |
| 589 | break; |
| 590 | } |
| 591 | //Fall through for pointer size == int size |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 592 | case Type::UIntTyID: case Type::IntTyID: |
| 593 | O << Data32bitsDirective; |
| 594 | break; |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 595 | case Type::ULongTyID: case Type::LongTyID: |
Chris Lattner | 660538c | 2005-08-08 04:26:32 +0000 | [diff] [blame] | 596 | assert(Data64bitsDirective &&"Target cannot handle 64-bit constant exprs!"); |
| 597 | O << Data64bitsDirective; |
| 598 | break; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 599 | case Type::FloatTyID: case Type::DoubleTyID: |
| 600 | assert (0 && "Should have already output floating point constant."); |
| 601 | default: |
| 602 | assert (0 && "Can't handle printing this type of thing"); |
| 603 | break; |
| 604 | } |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 605 | EmitConstantValueOnly(CV); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 606 | O << "\n"; |
| 607 | } |
Chris Lattner | 0264d1a | 2006-01-27 02:10:10 +0000 | [diff] [blame] | 608 | |
| 609 | /// printInlineAsm - This method formats and prints the specified machine |
| 610 | /// instruction that is an inline asm. |
| 611 | void AsmPrinter::printInlineAsm(const MachineInstr *MI) const { |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 612 | O << InlineAsmStart << "\n\t"; |
Chris Lattner | f2b67cf | 2006-01-30 23:00:08 +0000 | [diff] [blame] | 613 | unsigned NumOperands = MI->getNumOperands(); |
| 614 | |
| 615 | // Count the number of register definitions. |
| 616 | unsigned NumDefs = 0; |
| 617 | for (; MI->getOperand(NumDefs).isDef(); ++NumDefs) |
| 618 | assert(NumDefs != NumOperands-1 && "No asm string?"); |
| 619 | |
| 620 | assert(MI->getOperand(NumDefs).isExternalSymbol() && "No asm string?"); |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 621 | |
| 622 | // Disassemble the AsmStr, printing out the literal pieces, the operands, etc. |
Chris Lattner | f2b67cf | 2006-01-30 23:00:08 +0000 | [diff] [blame] | 623 | const char *AsmStr = MI->getOperand(NumDefs).getSymbolName(); |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 624 | |
| 625 | // The variant of the current asmprinter: FIXME: change. |
| 626 | int AsmPrinterVariant = 0; |
Chris Lattner | f2b67cf | 2006-01-30 23:00:08 +0000 | [diff] [blame] | 627 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 628 | int CurVariant = -1; // The number of the {.|.|.} region we are in. |
| 629 | const char *LastEmitted = AsmStr; // One past the last character emitted. |
Chris Lattner | 2cc2f66 | 2006-02-01 01:28:23 +0000 | [diff] [blame] | 630 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 631 | while (*LastEmitted) { |
| 632 | switch (*LastEmitted) { |
| 633 | default: { |
| 634 | // Not a special case, emit the string section literally. |
| 635 | const char *LiteralEnd = LastEmitted+1; |
| 636 | while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 637 | *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 638 | ++LiteralEnd; |
| 639 | if (CurVariant == -1 || CurVariant == AsmPrinterVariant) |
| 640 | O.write(LastEmitted, LiteralEnd-LastEmitted); |
| 641 | LastEmitted = LiteralEnd; |
| 642 | break; |
| 643 | } |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 644 | case '\n': |
| 645 | ++LastEmitted; // Consume newline character. |
| 646 | O << "\n\t"; // Indent code with newline. |
| 647 | break; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 648 | case '$': { |
| 649 | ++LastEmitted; // Consume '$' character. |
| 650 | if (*LastEmitted == '$') { // $$ -> $ |
| 651 | if (CurVariant == -1 || CurVariant == AsmPrinterVariant) |
| 652 | O << '$'; |
| 653 | ++LastEmitted; // Consume second '$' character. |
| 654 | break; |
| 655 | } |
| 656 | |
| 657 | bool HasCurlyBraces = false; |
| 658 | if (*LastEmitted == '{') { // ${variable} |
| 659 | ++LastEmitted; // Consume '{' character. |
| 660 | HasCurlyBraces = true; |
| 661 | } |
| 662 | |
| 663 | const char *IDStart = LastEmitted; |
| 664 | char *IDEnd; |
| 665 | long Val = strtol(IDStart, &IDEnd, 10); // We only accept numbers for IDs. |
| 666 | if (!isdigit(*IDStart) || (Val == 0 && errno == EINVAL)) { |
| 667 | std::cerr << "Bad $ operand number in inline asm string: '" |
| 668 | << AsmStr << "'\n"; |
| 669 | exit(1); |
| 670 | } |
| 671 | LastEmitted = IDEnd; |
| 672 | |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 673 | char Modifier[2] = { 0, 0 }; |
| 674 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 675 | if (HasCurlyBraces) { |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 676 | // If we have curly braces, check for a modifier character. This |
| 677 | // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm. |
| 678 | if (*LastEmitted == ':') { |
| 679 | ++LastEmitted; // Consume ':' character. |
| 680 | if (*LastEmitted == 0) { |
| 681 | std::cerr << "Bad ${:} expression in inline asm string: '" |
| 682 | << AsmStr << "'\n"; |
| 683 | exit(1); |
| 684 | } |
| 685 | |
| 686 | Modifier[0] = *LastEmitted; |
| 687 | ++LastEmitted; // Consume modifier character. |
| 688 | } |
| 689 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 690 | if (*LastEmitted != '}') { |
| 691 | std::cerr << "Bad ${} expression in inline asm string: '" |
| 692 | << AsmStr << "'\n"; |
| 693 | exit(1); |
| 694 | } |
| 695 | ++LastEmitted; // Consume '}' character. |
| 696 | } |
| 697 | |
| 698 | if ((unsigned)Val >= NumOperands-1) { |
| 699 | std::cerr << "Invalid $ operand number in inline asm string: '" |
| 700 | << AsmStr << "'\n"; |
| 701 | exit(1); |
| 702 | } |
| 703 | |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 704 | // Okay, we finally have a value number. Ask the target to print this |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 705 | // operand! |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 706 | if (CurVariant == -1 || CurVariant == AsmPrinterVariant) { |
| 707 | unsigned OpNo = 1; |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 708 | |
| 709 | bool Error = false; |
| 710 | |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 711 | // Scan to find the machine operand number for the operand. |
Chris Lattner | daf6bc6 | 2006-02-24 19:50:58 +0000 | [diff] [blame] | 712 | for (; Val; --Val) { |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 713 | if (OpNo >= MI->getNumOperands()) break; |
Chris Lattner | daf6bc6 | 2006-02-24 19:50:58 +0000 | [diff] [blame] | 714 | unsigned OpFlags = MI->getOperand(OpNo).getImmedValue(); |
| 715 | OpNo += (OpFlags >> 3) + 1; |
| 716 | } |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 717 | |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 718 | if (OpNo >= MI->getNumOperands()) { |
| 719 | Error = true; |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 720 | } else { |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 721 | unsigned OpFlags = MI->getOperand(OpNo).getImmedValue(); |
| 722 | ++OpNo; // Skip over the ID number. |
| 723 | |
| 724 | AsmPrinter *AP = const_cast<AsmPrinter*>(this); |
| 725 | if ((OpFlags & 7) == 4 /*ADDR MODE*/) { |
| 726 | Error = AP->PrintAsmMemoryOperand(MI, OpNo, AsmPrinterVariant, |
| 727 | Modifier[0] ? Modifier : 0); |
| 728 | } else { |
| 729 | Error = AP->PrintAsmOperand(MI, OpNo, AsmPrinterVariant, |
| 730 | Modifier[0] ? Modifier : 0); |
| 731 | } |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 732 | } |
| 733 | if (Error) { |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 734 | std::cerr << "Invalid operand found in inline asm: '" |
| 735 | << AsmStr << "'\n"; |
| 736 | MI->dump(); |
| 737 | exit(1); |
| 738 | } |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 739 | } |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 740 | break; |
| 741 | } |
| 742 | case '{': |
| 743 | ++LastEmitted; // Consume '{' character. |
| 744 | if (CurVariant != -1) { |
| 745 | std::cerr << "Nested variants found in inline asm string: '" |
| 746 | << AsmStr << "'\n"; |
| 747 | exit(1); |
| 748 | } |
| 749 | CurVariant = 0; // We're in the first variant now. |
| 750 | break; |
| 751 | case '|': |
| 752 | ++LastEmitted; // consume '|' character. |
| 753 | if (CurVariant == -1) { |
| 754 | std::cerr << "Found '|' character outside of variant in inline asm " |
| 755 | << "string: '" << AsmStr << "'\n"; |
| 756 | exit(1); |
| 757 | } |
| 758 | ++CurVariant; // We're in the next variant. |
| 759 | break; |
| 760 | case '}': |
| 761 | ++LastEmitted; // consume '}' character. |
| 762 | if (CurVariant == -1) { |
| 763 | std::cerr << "Found '}' character outside of variant in inline asm " |
| 764 | << "string: '" << AsmStr << "'\n"; |
| 765 | exit(1); |
| 766 | } |
| 767 | CurVariant = -1; |
| 768 | break; |
| 769 | } |
| 770 | } |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 771 | O << "\n\t" << InlineAsmEnd << "\n"; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 772 | } |
| 773 | |
| 774 | /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM |
| 775 | /// instruction, using the specified assembler variant. Targets should |
| 776 | /// overried this to format as appropriate. |
| 777 | bool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 778 | unsigned AsmVariant, const char *ExtraCode) { |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 779 | // Target doesn't support this yet! |
| 780 | return true; |
Chris Lattner | 0264d1a | 2006-01-27 02:10:10 +0000 | [diff] [blame] | 781 | } |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 782 | |
| 783 | bool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, |
| 784 | unsigned AsmVariant, |
| 785 | const char *ExtraCode) { |
| 786 | // Target doesn't support this yet! |
| 787 | return true; |
| 788 | } |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 789 | |
| 790 | /// printBasicBlockLabel - This method prints the label for the specified |
| 791 | /// MachineBasicBlock |
Nate Begeman | cdf38c4 | 2006-05-02 05:37:32 +0000 | [diff] [blame] | 792 | void AsmPrinter::printBasicBlockLabel(const MachineBasicBlock *MBB, |
| 793 | bool printColon, |
| 794 | bool printComment) const { |
Nate Begeman | 9d51eeb | 2006-05-02 17:36:46 +0000 | [diff] [blame] | 795 | O << PrivateGlobalPrefix << "BB" << FunctionNumber << "_" |
| 796 | << MBB->getNumber(); |
Nate Begeman | cdf38c4 | 2006-05-02 05:37:32 +0000 | [diff] [blame] | 797 | if (printColon) |
| 798 | O << ':'; |
| 799 | if (printComment) |
| 800 | O << '\t' << CommentString << MBB->getBasicBlock()->getName(); |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 801 | } |