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" |
Jim Laskey | f1cdea1 | 2007-01-25 15:12:02 +0000 | [diff] [blame] | 21 | #include "llvm/Support/CommandLine.h" |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 22 | #include "llvm/Support/Mangler.h" |
Jim Laskey | cb6682f | 2005-08-17 19:34:49 +0000 | [diff] [blame] | 23 | #include "llvm/Support/MathExtras.h" |
Bill Wendling | bdc679d | 2006-11-29 00:39:47 +0000 | [diff] [blame] | 24 | #include "llvm/Support/Streams.h" |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 25 | #include "llvm/Target/TargetAsmInfo.h" |
Owen Anderson | 07000c6 | 2006-05-12 06:33:49 +0000 | [diff] [blame] | 26 | #include "llvm/Target/TargetData.h" |
Chris Lattner | 0336fdb | 2006-10-06 22:50:56 +0000 | [diff] [blame] | 27 | #include "llvm/Target/TargetLowering.h" |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 28 | #include "llvm/Target/TargetMachine.h" |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 29 | #include <cerrno> |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 30 | using namespace llvm; |
| 31 | |
Jim Laskey | f1cdea1 | 2007-01-25 15:12:02 +0000 | [diff] [blame] | 32 | static cl::opt<bool> |
| 33 | AsmVerbose("asm-verbose", cl::Hidden, cl::desc("Add comments to directives.")); |
| 34 | |
Jim Laskey | a0f3d17 | 2006-09-07 22:06:40 +0000 | [diff] [blame] | 35 | AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm, |
| 36 | const TargetAsmInfo *T) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 37 | : FunctionNumber(0), O(o), TM(tm), TAI(T) |
| 38 | {} |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 39 | |
Chris Lattner | 52f0670 | 2006-10-05 02:42:47 +0000 | [diff] [blame] | 40 | std::string AsmPrinter::getSectionForFunction(const Function &F) const { |
| 41 | return TAI->getTextSection(); |
| 42 | } |
| 43 | |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 44 | |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 45 | /// SwitchToTextSection - Switch to the specified text section of the executable |
| 46 | /// if we are not already in it! |
Chris Lattner | ac28fbd | 2005-11-21 07:06:27 +0000 | [diff] [blame] | 47 | /// |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 48 | void AsmPrinter::SwitchToTextSection(const char *NewSection, |
| 49 | const GlobalValue *GV) { |
Chris Lattner | ac28fbd | 2005-11-21 07:06:27 +0000 | [diff] [blame] | 50 | std::string NS; |
Chris Lattner | a7090ae | 2006-05-09 05:24:50 +0000 | [diff] [blame] | 51 | if (GV && GV->hasSection()) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 52 | NS = TAI->getSwitchToSectionDirective() + GV->getSection(); |
Chris Lattner | a7090ae | 2006-05-09 05:24:50 +0000 | [diff] [blame] | 53 | else |
| 54 | NS = NewSection; |
| 55 | |
| 56 | // If we're already in this section, we're done. |
| 57 | if (CurrentSection == NS) return; |
Jeff Cohen | 51b776d | 2006-05-02 03:58:45 +0000 | [diff] [blame] | 58 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 59 | // Close the current section, if applicable. |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 60 | if (TAI->getSectionEndDirectiveSuffix() && !CurrentSection.empty()) |
| 61 | O << CurrentSection << TAI->getSectionEndDirectiveSuffix() << "\n"; |
Jeff Cohen | 51b776d | 2006-05-02 03:58:45 +0000 | [diff] [blame] | 62 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 63 | CurrentSection = NS; |
| 64 | |
| 65 | if (!CurrentSection.empty()) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 66 | O << CurrentSection << TAI->getTextSectionStartSuffix() << '\n'; |
Chris Lattner | ac28fbd | 2005-11-21 07:06:27 +0000 | [diff] [blame] | 67 | } |
| 68 | |
Nate Begeman | 2f1ae88 | 2006-07-27 01:13:04 +0000 | [diff] [blame] | 69 | /// SwitchToDataSection - Switch to the specified data section of the executable |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 70 | /// if we are not already in it! |
| 71 | /// |
| 72 | void AsmPrinter::SwitchToDataSection(const char *NewSection, |
| 73 | const GlobalValue *GV) { |
| 74 | std::string NS; |
Chris Lattner | b81cb61 | 2006-05-09 05:23:12 +0000 | [diff] [blame] | 75 | if (GV && GV->hasSection()) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 76 | NS = TAI->getSwitchToSectionDirective() + GV->getSection(); |
Chris Lattner | b81cb61 | 2006-05-09 05:23:12 +0000 | [diff] [blame] | 77 | else |
| 78 | NS = NewSection; |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 79 | |
Chris Lattner | b81cb61 | 2006-05-09 05:23:12 +0000 | [diff] [blame] | 80 | // If we're already in this section, we're done. |
| 81 | if (CurrentSection == NS) return; |
| 82 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 83 | // Close the current section, if applicable. |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 84 | if (TAI->getSectionEndDirectiveSuffix() && !CurrentSection.empty()) |
| 85 | O << CurrentSection << TAI->getSectionEndDirectiveSuffix() << "\n"; |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 86 | |
| 87 | CurrentSection = NS; |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 88 | |
Chris Lattner | 7faec9b | 2006-05-09 05:33:48 +0000 | [diff] [blame] | 89 | if (!CurrentSection.empty()) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 90 | O << CurrentSection << TAI->getDataSectionStartSuffix() << '\n'; |
Chris Lattner | 4632d7a | 2006-05-09 04:59:56 +0000 | [diff] [blame] | 91 | } |
| 92 | |
| 93 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 94 | bool AsmPrinter::doInitialization(Module &M) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 95 | Mang = new Mangler(M, TAI->getGlobalPrefix()); |
Chris Lattner | 2c1b159 | 2006-01-23 23:47:53 +0000 | [diff] [blame] | 96 | |
Chris Lattner | 3e2fa7a | 2006-01-24 04:16:34 +0000 | [diff] [blame] | 97 | if (!M.getModuleInlineAsm().empty()) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 98 | O << TAI->getCommentString() << " Start of file scope inline assembly\n" |
Chris Lattner | 3e2fa7a | 2006-01-24 04:16:34 +0000 | [diff] [blame] | 99 | << M.getModuleInlineAsm() |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 100 | << "\n" << TAI->getCommentString() |
| 101 | << " End of file scope inline assembly\n"; |
Chris Lattner | 2c1b159 | 2006-01-23 23:47:53 +0000 | [diff] [blame] | 102 | |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 103 | SwitchToDataSection(""); // Reset back to no section. |
Jim Laskey | b3e789a | 2006-01-26 20:21:46 +0000 | [diff] [blame] | 104 | |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 105 | if (MachineModuleInfo *MMI = getAnalysisToUpdate<MachineModuleInfo>()) { |
| 106 | MMI->AnalyzeModule(M); |
Jim Laskey | b3e789a | 2006-01-26 20:21:46 +0000 | [diff] [blame] | 107 | } |
| 108 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 109 | return false; |
| 110 | } |
| 111 | |
| 112 | bool AsmPrinter::doFinalization(Module &M) { |
Rafael Espindola | 15404d0 | 2006-12-18 03:37:18 +0000 | [diff] [blame] | 113 | if (TAI->getWeakRefDirective()) { |
| 114 | if (ExtWeakSymbols.begin() != ExtWeakSymbols.end()) |
| 115 | SwitchToDataSection(""); |
| 116 | |
| 117 | for (std::set<const GlobalValue*>::iterator i = ExtWeakSymbols.begin(), |
| 118 | e = ExtWeakSymbols.end(); i != e; ++i) { |
| 119 | const GlobalValue *GV = *i; |
| 120 | std::string Name = Mang->getValueName(GV); |
| 121 | O << TAI->getWeakRefDirective() << Name << "\n"; |
| 122 | } |
| 123 | } |
| 124 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 125 | delete Mang; Mang = 0; |
| 126 | return false; |
| 127 | } |
| 128 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 129 | void AsmPrinter::SetupMachineFunction(MachineFunction &MF) { |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 130 | // What's my mangled name? |
Chris Lattner | 450de39 | 2005-11-10 18:36:17 +0000 | [diff] [blame] | 131 | CurrentFnName = Mang->getValueName(MF.getFunction()); |
Chris Lattner | 77bc228 | 2005-11-21 08:13:27 +0000 | [diff] [blame] | 132 | IncrementFunctionNumber(); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 133 | } |
| 134 | |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 135 | /// EmitConstantPool - Print to the current output stream assembly |
| 136 | /// representations of the constants in the constant pool MCP. This is |
| 137 | /// used to print out constants which have been "spilled to memory" by |
| 138 | /// the code generator. |
| 139 | /// |
| 140 | void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) { |
Chris Lattner | fa77d43 | 2006-02-09 04:22:52 +0000 | [diff] [blame] | 141 | const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 142 | if (CP.empty()) return; |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 143 | |
| 144 | // Some targets require 4-, 8-, and 16- byte constant literals to be placed |
| 145 | // in special sections. |
| 146 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > FourByteCPs; |
| 147 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > EightByteCPs; |
| 148 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > SixteenByteCPs; |
| 149 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > OtherCPs; |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 150 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > TargetCPs; |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 151 | for (unsigned i = 0, e = CP.size(); i != e; ++i) { |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 152 | MachineConstantPoolEntry CPE = CP[i]; |
Evan Cheng | d5a99d7 | 2006-09-14 07:35:00 +0000 | [diff] [blame] | 153 | const Type *Ty = CPE.getType(); |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 154 | if (TAI->getFourByteConstantSection() && |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 155 | TM.getTargetData()->getTypeSize(Ty) == 4) |
| 156 | FourByteCPs.push_back(std::make_pair(CPE, i)); |
Evan Cheng | 61c958e | 2006-09-07 18:50:20 +0000 | [diff] [blame] | 157 | else if (TAI->getEightByteConstantSection() && |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 158 | TM.getTargetData()->getTypeSize(Ty) == 8) |
| 159 | EightByteCPs.push_back(std::make_pair(CPE, i)); |
Evan Cheng | 61c958e | 2006-09-07 18:50:20 +0000 | [diff] [blame] | 160 | else if (TAI->getSixteenByteConstantSection() && |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 161 | TM.getTargetData()->getTypeSize(Ty) == 16) |
| 162 | SixteenByteCPs.push_back(std::make_pair(CPE, i)); |
| 163 | else |
| 164 | OtherCPs.push_back(std::make_pair(CPE, i)); |
| 165 | } |
| 166 | |
| 167 | unsigned Alignment = MCP->getConstantPoolAlignment(); |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 168 | EmitConstantPool(Alignment, TAI->getFourByteConstantSection(), FourByteCPs); |
| 169 | EmitConstantPool(Alignment, TAI->getEightByteConstantSection(), EightByteCPs); |
| 170 | EmitConstantPool(Alignment, TAI->getSixteenByteConstantSection(), |
| 171 | SixteenByteCPs); |
| 172 | EmitConstantPool(Alignment, TAI->getConstantPoolSection(), OtherCPs); |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | void AsmPrinter::EmitConstantPool(unsigned Alignment, const char *Section, |
| 176 | std::vector<std::pair<MachineConstantPoolEntry,unsigned> > &CP) { |
| 177 | if (CP.empty()) return; |
| 178 | |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 179 | SwitchToDataSection(Section); |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 180 | EmitAlignment(Alignment); |
| 181 | for (unsigned i = 0, e = CP.size(); i != e; ++i) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 182 | O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_' |
| 183 | << CP[i].second << ":\t\t\t\t\t" << TAI->getCommentString() << " "; |
Evan Cheng | d5a99d7 | 2006-09-14 07:35:00 +0000 | [diff] [blame] | 184 | WriteTypeSymbolic(O, CP[i].first.getType(), 0) << '\n'; |
| 185 | if (CP[i].first.isMachineConstantPoolEntry()) |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 186 | EmitMachineConstantPoolValue(CP[i].first.Val.MachineCPVal); |
Evan Cheng | d5a99d7 | 2006-09-14 07:35:00 +0000 | [diff] [blame] | 187 | else |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 188 | EmitGlobalConstant(CP[i].first.Val.ConstVal); |
Chris Lattner | 3029f92 | 2006-02-09 04:46:04 +0000 | [diff] [blame] | 189 | if (i != e-1) { |
Evan Cheng | d5a99d7 | 2006-09-14 07:35:00 +0000 | [diff] [blame] | 190 | const Type *Ty = CP[i].first.getType(); |
Evan Cheng | 2d2cec1 | 2006-06-29 00:26:09 +0000 | [diff] [blame] | 191 | unsigned EntSize = |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 192 | TM.getTargetData()->getTypeSize(Ty); |
Evan Cheng | d5a99d7 | 2006-09-14 07:35:00 +0000 | [diff] [blame] | 193 | unsigned ValEnd = CP[i].first.getOffset() + EntSize; |
Chris Lattner | 3029f92 | 2006-02-09 04:46:04 +0000 | [diff] [blame] | 194 | // Emit inter-object padding for alignment. |
Evan Cheng | d5a99d7 | 2006-09-14 07:35:00 +0000 | [diff] [blame] | 195 | EmitZeros(CP[i+1].first.getOffset()-ValEnd); |
Chris Lattner | 3029f92 | 2006-02-09 04:46:04 +0000 | [diff] [blame] | 196 | } |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 197 | } |
| 198 | } |
| 199 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 200 | /// EmitJumpTableInfo - Print assembly representations of the jump tables used |
| 201 | /// by the current function to the current output stream. |
| 202 | /// |
Chris Lattner | 1da31ee | 2006-10-05 03:01:21 +0000 | [diff] [blame] | 203 | void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI, |
| 204 | MachineFunction &MF) { |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 205 | const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); |
| 206 | if (JT.empty()) return; |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 207 | bool IsPic = TM.getRelocationModel() == Reloc::PIC_; |
Nate Begeman | 4d9bbdc | 2006-07-27 16:46:58 +0000 | [diff] [blame] | 208 | |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 209 | // Use JumpTableDirective otherwise honor the entry size from the jump table |
| 210 | // info. |
Andrew Lenharth | beec30e | 2006-09-24 19:45:58 +0000 | [diff] [blame] | 211 | const char *JTEntryDirective = TAI->getJumpTableDirective(); |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 212 | bool HadJTEntryDirective = JTEntryDirective != NULL; |
| 213 | if (!HadJTEntryDirective) { |
| 214 | JTEntryDirective = MJTI->getEntrySize() == 4 ? |
| 215 | TAI->getData32bitsDirective() : TAI->getData64bitsDirective(); |
| 216 | } |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 217 | |
Nate Begeman | 2f1ae88 | 2006-07-27 01:13:04 +0000 | [diff] [blame] | 218 | // Pick the directive to use to print the jump table entries, and switch to |
| 219 | // the appropriate section. |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 220 | TargetLowering *LoweringInfo = TM.getTargetLowering(); |
Anton Korobeynikov | 24287dd | 2006-12-19 21:04:20 +0000 | [diff] [blame] | 221 | |
| 222 | const char* JumpTableDataSection = TAI->getJumpTableDataSection(); |
| 223 | if ((IsPic && !(LoweringInfo && LoweringInfo->usesGlobalOffsetTable())) || |
| 224 | !JumpTableDataSection) { |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 225 | // In PIC mode, we need to emit the jump table to the same section as the |
| 226 | // function body itself, otherwise the label differences won't make sense. |
Anton Korobeynikov | 24287dd | 2006-12-19 21:04:20 +0000 | [diff] [blame] | 227 | // We should also do if the section name is NULL. |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 228 | const Function *F = MF.getFunction(); |
| 229 | SwitchToTextSection(getSectionForFunction(*F).c_str(), F); |
Nate Begeman | 2f1ae88 | 2006-07-27 01:13:04 +0000 | [diff] [blame] | 230 | } else { |
Anton Korobeynikov | 24287dd | 2006-12-19 21:04:20 +0000 | [diff] [blame] | 231 | SwitchToDataSection(JumpTableDataSection); |
Nate Begeman | 2f1ae88 | 2006-07-27 01:13:04 +0000 | [diff] [blame] | 232 | } |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 233 | |
| 234 | EmitAlignment(Log2_32(MJTI->getAlignment())); |
Chris Lattner | 0c4e678 | 2006-07-15 01:34:12 +0000 | [diff] [blame] | 235 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 236 | for (unsigned i = 0, e = JT.size(); i != e; ++i) { |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 237 | const std::vector<MachineBasicBlock*> &JTBBs = JT[i].MBBs; |
Chris Lattner | 0737188 | 2006-10-28 18:10:06 +0000 | [diff] [blame] | 238 | |
| 239 | // If this jump table was deleted, ignore it. |
| 240 | if (JTBBs.empty()) continue; |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 241 | |
| 242 | // For PIC codegen, if possible we want to use the SetDirective to reduce |
| 243 | // the number of relocations the assembler will generate for the jump table. |
| 244 | // Set directives are all printed before the jump table itself. |
| 245 | std::set<MachineBasicBlock*> EmittedSets; |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 246 | if (TAI->getSetDirective() && IsPic) |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 247 | for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) |
| 248 | if (EmittedSets.insert(JTBBs[ii]).second) |
| 249 | printSetLabel(i, JTBBs[ii]); |
| 250 | |
Chris Lattner | 393a8ee | 2007-01-18 01:12:56 +0000 | [diff] [blame] | 251 | // On some targets (e.g. darwin) we want to emit two consequtive labels |
| 252 | // before each jump table. The first label is never referenced, but tells |
| 253 | // the assembler and linker the extents of the jump table object. The |
| 254 | // second label is actually referenced by the code. |
| 255 | if (const char *JTLabelPrefix = TAI->getJumpTableSpecialLabelPrefix()) |
| 256 | O << JTLabelPrefix << "JTI" << getFunctionNumber() << '_' << i << ":\n"; |
| 257 | |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 258 | O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() |
| 259 | << '_' << i << ":\n"; |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 260 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 261 | for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { |
Nate Begeman | 4d9bbdc | 2006-07-27 16:46:58 +0000 | [diff] [blame] | 262 | O << JTEntryDirective << ' '; |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 263 | // If we have emitted set directives for the jump table entries, print |
| 264 | // them rather than the entries themselves. If we're emitting PIC, then |
| 265 | // emit the table entries as differences between two text section labels. |
| 266 | // If we're emitting non-PIC code, then emit the entries as direct |
| 267 | // references to the target basic blocks. |
| 268 | if (!EmittedSets.empty()) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 269 | O << TAI->getPrivateGlobalPrefix() << getFunctionNumber() |
| 270 | << '_' << i << "_set_" << JTBBs[ii]->getNumber(); |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 271 | } else if (IsPic) { |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 272 | printBasicBlockLabel(JTBBs[ii], false, false); |
Chris Lattner | 393a8ee | 2007-01-18 01:12:56 +0000 | [diff] [blame] | 273 | // If the arch uses custom Jump Table directives, don't calc relative to |
| 274 | // JT |
Jim Laskey | acd80ac | 2006-12-14 19:17:33 +0000 | [diff] [blame] | 275 | if (!HadJTEntryDirective) |
| 276 | O << '-' << TAI->getPrivateGlobalPrefix() << "JTI" |
| 277 | << getFunctionNumber() << '_' << i; |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 278 | } else { |
| 279 | printBasicBlockLabel(JTBBs[ii], false, false); |
Nate Begeman | 2f1ae88 | 2006-07-27 01:13:04 +0000 | [diff] [blame] | 280 | } |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 281 | O << '\n'; |
| 282 | } |
| 283 | } |
| 284 | } |
| 285 | |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 286 | /// EmitSpecialLLVMGlobal - Check to see if the specified global is a |
| 287 | /// special global used by LLVM. If so, emit it and return true, otherwise |
| 288 | /// do nothing and return false. |
| 289 | bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { |
Jim Laskey | 7809811 | 2006-03-07 22:00:35 +0000 | [diff] [blame] | 290 | // Ignore debug and non-emitted data. |
| 291 | if (GV->getSection() == "llvm.metadata") return true; |
| 292 | |
| 293 | if (!GV->hasAppendingLinkage()) return false; |
| 294 | |
| 295 | assert(GV->hasInitializer() && "Not a special LLVM global!"); |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 296 | |
Chris Lattner | cb05af8 | 2006-09-26 03:38:18 +0000 | [diff] [blame] | 297 | if (GV->getName() == "llvm.used") { |
| 298 | if (TAI->getUsedDirective() != 0) // No need to emit this at all. |
| 299 | EmitLLVMUsedList(GV->getInitializer()); |
| 300 | return true; |
| 301 | } |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 302 | |
Chris Lattner | 5166b82 | 2006-01-12 19:17:23 +0000 | [diff] [blame] | 303 | if (GV->getName() == "llvm.global_ctors" && GV->use_empty()) { |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 304 | SwitchToDataSection(TAI->getStaticCtorsSection()); |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 305 | EmitAlignment(2, 0); |
| 306 | EmitXXStructorList(GV->getInitializer()); |
| 307 | return true; |
| 308 | } |
| 309 | |
Chris Lattner | 5166b82 | 2006-01-12 19:17:23 +0000 | [diff] [blame] | 310 | if (GV->getName() == "llvm.global_dtors" && GV->use_empty()) { |
Anton Korobeynikov | ab4022f | 2006-10-31 08:31:24 +0000 | [diff] [blame] | 311 | SwitchToDataSection(TAI->getStaticDtorsSection()); |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 312 | EmitAlignment(2, 0); |
| 313 | EmitXXStructorList(GV->getInitializer()); |
| 314 | return true; |
| 315 | } |
| 316 | |
| 317 | return false; |
| 318 | } |
| 319 | |
Chris Lattner | cb05af8 | 2006-09-26 03:38:18 +0000 | [diff] [blame] | 320 | /// EmitLLVMUsedList - For targets that define a TAI::UsedDirective, mark each |
| 321 | /// global in the specified llvm.used list as being used with this directive. |
| 322 | void AsmPrinter::EmitLLVMUsedList(Constant *List) { |
| 323 | const char *Directive = TAI->getUsedDirective(); |
| 324 | |
| 325 | // Should be an array of 'sbyte*'. |
| 326 | ConstantArray *InitList = dyn_cast<ConstantArray>(List); |
| 327 | if (InitList == 0) return; |
| 328 | |
| 329 | for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { |
| 330 | O << Directive; |
| 331 | EmitConstantValueOnly(InitList->getOperand(i)); |
| 332 | O << "\n"; |
| 333 | } |
| 334 | } |
| 335 | |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 336 | /// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the |
| 337 | /// function pointers, ignoring the init priority. |
| 338 | void AsmPrinter::EmitXXStructorList(Constant *List) { |
| 339 | // Should be an array of '{ int, void ()* }' structs. The first value is the |
| 340 | // init priority, which we ignore. |
| 341 | if (!isa<ConstantArray>(List)) return; |
| 342 | ConstantArray *InitList = cast<ConstantArray>(List); |
| 343 | for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) |
| 344 | if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ |
| 345 | if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. |
Chris Lattner | 8de324b | 2005-12-21 01:17:37 +0000 | [diff] [blame] | 346 | |
| 347 | if (CS->getOperand(1)->isNullValue()) |
| 348 | return; // Found a null terminator, exit printing. |
| 349 | // Emit the function pointer. |
Chris Lattner | ed13893 | 2005-12-13 06:32:10 +0000 | [diff] [blame] | 350 | EmitGlobalConstant(CS->getOperand(1)); |
| 351 | } |
| 352 | } |
Chris Lattner | 3b4fd32 | 2005-11-21 08:25:09 +0000 | [diff] [blame] | 353 | |
Jim Laskey | a1a19f8 | 2006-10-17 13:41:07 +0000 | [diff] [blame] | 354 | /// getGlobalLinkName - Returns the asm/link name of of the specified |
| 355 | /// global variable. Should be overridden by each target asm printer to |
| 356 | /// generate the appropriate value. |
Jim Laskey | 99e41ee | 2006-10-17 17:17:24 +0000 | [diff] [blame] | 357 | const std::string AsmPrinter::getGlobalLinkName(const GlobalVariable *GV) const{ |
| 358 | std::string LinkName; |
Jim Laskey | 0374248 | 2006-11-20 20:29:06 +0000 | [diff] [blame] | 359 | |
| 360 | if (isa<Function>(GV)) { |
| 361 | LinkName += TAI->getFunctionAddrPrefix(); |
| 362 | LinkName += Mang->getValueName(GV); |
| 363 | LinkName += TAI->getFunctionAddrSuffix(); |
| 364 | } else { |
| 365 | LinkName += TAI->getGlobalVarAddrPrefix(); |
| 366 | LinkName += Mang->getValueName(GV); |
| 367 | LinkName += TAI->getGlobalVarAddrSuffix(); |
| 368 | } |
| 369 | |
Jim Laskey | 99e41ee | 2006-10-17 17:17:24 +0000 | [diff] [blame] | 370 | return LinkName; |
Jim Laskey | a1a19f8 | 2006-10-17 13:41:07 +0000 | [diff] [blame] | 371 | } |
| 372 | |
Jim Laskey | bda9b0e | 2007-02-21 22:47:38 +0000 | [diff] [blame^] | 373 | /// EmitExternalGlobal - Emit the external reference to a global variable. |
| 374 | /// Should be overridden if an indirect reference should be used. |
| 375 | void AsmPrinter::EmitExternalGlobal(const GlobalVariable *GV) { |
| 376 | O << getGlobalLinkName(GV); |
| 377 | } |
| 378 | |
| 379 | |
| 380 | |
Jim Laskey | f1cdea1 | 2007-01-25 15:12:02 +0000 | [diff] [blame] | 381 | //===----------------------------------------------------------------------===// |
| 382 | /// LEB 128 number encoding. |
| 383 | |
| 384 | /// PrintULEB128 - Print a series of hexidecimal values (separated by commas) |
| 385 | /// representing an unsigned leb128 value. |
| 386 | void AsmPrinter::PrintULEB128(unsigned Value) const { |
| 387 | do { |
| 388 | unsigned Byte = Value & 0x7f; |
| 389 | Value >>= 7; |
| 390 | if (Value) Byte |= 0x80; |
| 391 | O << "0x" << std::hex << Byte << std::dec; |
| 392 | if (Value) O << ", "; |
| 393 | } while (Value); |
| 394 | } |
| 395 | |
| 396 | /// SizeULEB128 - Compute the number of bytes required for an unsigned leb128 |
| 397 | /// value. |
| 398 | unsigned AsmPrinter::SizeULEB128(unsigned Value) { |
| 399 | unsigned Size = 0; |
| 400 | do { |
| 401 | Value >>= 7; |
| 402 | Size += sizeof(int8_t); |
| 403 | } while (Value); |
| 404 | return Size; |
| 405 | } |
| 406 | |
| 407 | /// PrintSLEB128 - Print a series of hexidecimal values (separated by commas) |
| 408 | /// representing a signed leb128 value. |
| 409 | void AsmPrinter::PrintSLEB128(int Value) const { |
| 410 | int Sign = Value >> (8 * sizeof(Value) - 1); |
| 411 | bool IsMore; |
| 412 | |
| 413 | do { |
| 414 | unsigned Byte = Value & 0x7f; |
| 415 | Value >>= 7; |
| 416 | IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0; |
| 417 | if (IsMore) Byte |= 0x80; |
| 418 | O << "0x" << std::hex << Byte << std::dec; |
| 419 | if (IsMore) O << ", "; |
| 420 | } while (IsMore); |
| 421 | } |
| 422 | |
| 423 | /// SizeSLEB128 - Compute the number of bytes required for a signed leb128 |
| 424 | /// value. |
| 425 | unsigned AsmPrinter::SizeSLEB128(int Value) { |
| 426 | unsigned Size = 0; |
| 427 | int Sign = Value >> (8 * sizeof(Value) - 1); |
| 428 | bool IsMore; |
| 429 | |
| 430 | do { |
| 431 | unsigned Byte = Value & 0x7f; |
| 432 | Value >>= 7; |
| 433 | IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0; |
| 434 | Size += sizeof(int8_t); |
| 435 | } while (IsMore); |
| 436 | return Size; |
| 437 | } |
| 438 | |
| 439 | //===--------------------------------------------------------------------===// |
| 440 | // Emission and print routines |
| 441 | // |
| 442 | |
| 443 | /// PrintHex - Print a value as a hexidecimal value. |
| 444 | /// |
| 445 | void AsmPrinter::PrintHex(int Value) const { |
| 446 | O << "0x" << std::hex << Value << std::dec; |
| 447 | } |
| 448 | |
| 449 | /// EOL - Print a newline character to asm stream. If a comment is present |
| 450 | /// then it will be printed first. Comments should not contain '\n'. |
Jim Laskey | bda9b0e | 2007-02-21 22:47:38 +0000 | [diff] [blame^] | 451 | void AsmPrinter::EOL() const { |
| 452 | O << "\n"; |
| 453 | } |
Jim Laskey | f1cdea1 | 2007-01-25 15:12:02 +0000 | [diff] [blame] | 454 | void AsmPrinter::EOL(const std::string &Comment) const { |
| 455 | if (AsmVerbose && !Comment.empty()) { |
| 456 | O << "\t" |
| 457 | << TAI->getCommentString() |
| 458 | << " " |
| 459 | << Comment; |
| 460 | } |
| 461 | O << "\n"; |
| 462 | } |
| 463 | |
| 464 | /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an |
| 465 | /// unsigned leb128 value. |
| 466 | void AsmPrinter::EmitULEB128Bytes(unsigned Value) const { |
| 467 | if (TAI->hasLEB128()) { |
| 468 | O << "\t.uleb128\t" |
| 469 | << Value; |
| 470 | } else { |
| 471 | O << TAI->getData8bitsDirective(); |
| 472 | PrintULEB128(Value); |
| 473 | } |
| 474 | } |
| 475 | |
| 476 | /// EmitSLEB128Bytes - print an assembler byte data directive to compose a |
| 477 | /// signed leb128 value. |
| 478 | void AsmPrinter::EmitSLEB128Bytes(int Value) const { |
| 479 | if (TAI->hasLEB128()) { |
| 480 | O << "\t.sleb128\t" |
| 481 | << Value; |
| 482 | } else { |
| 483 | O << TAI->getData8bitsDirective(); |
| 484 | PrintSLEB128(Value); |
| 485 | } |
| 486 | } |
| 487 | |
| 488 | /// EmitInt8 - Emit a byte directive and value. |
| 489 | /// |
| 490 | void AsmPrinter::EmitInt8(int Value) const { |
| 491 | O << TAI->getData8bitsDirective(); |
| 492 | PrintHex(Value & 0xFF); |
| 493 | } |
| 494 | |
| 495 | /// EmitInt16 - Emit a short directive and value. |
| 496 | /// |
| 497 | void AsmPrinter::EmitInt16(int Value) const { |
| 498 | O << TAI->getData16bitsDirective(); |
| 499 | PrintHex(Value & 0xFFFF); |
| 500 | } |
| 501 | |
| 502 | /// EmitInt32 - Emit a long directive and value. |
| 503 | /// |
| 504 | void AsmPrinter::EmitInt32(int Value) const { |
| 505 | O << TAI->getData32bitsDirective(); |
| 506 | PrintHex(Value); |
| 507 | } |
| 508 | |
| 509 | /// EmitInt64 - Emit a long long directive and value. |
| 510 | /// |
| 511 | void AsmPrinter::EmitInt64(uint64_t Value) const { |
| 512 | if (TAI->getData64bitsDirective()) { |
| 513 | O << TAI->getData64bitsDirective(); |
| 514 | PrintHex(Value); |
| 515 | } else { |
| 516 | if (TM.getTargetData()->isBigEndian()) { |
| 517 | EmitInt32(unsigned(Value >> 32)); O << "\n"; |
| 518 | EmitInt32(unsigned(Value)); |
| 519 | } else { |
| 520 | EmitInt32(unsigned(Value)); O << "\n"; |
| 521 | EmitInt32(unsigned(Value >> 32)); |
| 522 | } |
| 523 | } |
| 524 | } |
| 525 | |
| 526 | /// toOctal - Convert the low order bits of X into an octal digit. |
| 527 | /// |
| 528 | static inline char toOctal(int X) { |
| 529 | return (X&7)+'0'; |
| 530 | } |
| 531 | |
| 532 | /// printStringChar - Print a char, escaped if necessary. |
| 533 | /// |
| 534 | static void printStringChar(std::ostream &O, unsigned char C) { |
| 535 | if (C == '"') { |
| 536 | O << "\\\""; |
| 537 | } else if (C == '\\') { |
| 538 | O << "\\\\"; |
| 539 | } else if (isprint(C)) { |
| 540 | O << C; |
| 541 | } else { |
| 542 | switch(C) { |
| 543 | case '\b': O << "\\b"; break; |
| 544 | case '\f': O << "\\f"; break; |
| 545 | case '\n': O << "\\n"; break; |
| 546 | case '\r': O << "\\r"; break; |
| 547 | case '\t': O << "\\t"; break; |
| 548 | default: |
| 549 | O << '\\'; |
| 550 | O << toOctal(C >> 6); |
| 551 | O << toOctal(C >> 3); |
| 552 | O << toOctal(C >> 0); |
| 553 | break; |
| 554 | } |
| 555 | } |
| 556 | } |
| 557 | |
| 558 | /// EmitString - Emit a string with quotes and a null terminator. |
| 559 | /// Special characters are emitted properly. |
| 560 | /// \literal (Eg. '\t') \endliteral |
| 561 | void AsmPrinter::EmitString(const std::string &String) const { |
| 562 | O << TAI->getAsciiDirective() |
| 563 | << "\""; |
| 564 | for (unsigned i = 0, N = String.size(); i < N; ++i) { |
| 565 | unsigned char C = String[i]; |
| 566 | printStringChar(O, C); |
| 567 | } |
| 568 | O << "\\0\""; |
| 569 | } |
| 570 | |
| 571 | |
| 572 | //===----------------------------------------------------------------------===// |
| 573 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 574 | // EmitAlignment - Emit an alignment directive to the specified power of two. |
| 575 | void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const { |
Chris Lattner | a1ab72d | 2005-11-14 19:00:06 +0000 | [diff] [blame] | 576 | if (GV && GV->getAlignment()) |
| 577 | NumBits = Log2_32(GV->getAlignment()); |
Chris Lattner | 2a21c6e | 2005-11-10 18:09:27 +0000 | [diff] [blame] | 578 | if (NumBits == 0) return; // No need to emit alignment. |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 579 | if (TAI->getAlignmentIsInBytes()) NumBits = 1 << NumBits; |
| 580 | O << TAI->getAlignDirective() << NumBits << "\n"; |
Chris Lattner | bfddc20 | 2004-08-17 19:14:29 +0000 | [diff] [blame] | 581 | } |
| 582 | |
Jim Laskey | bda9b0e | 2007-02-21 22:47:38 +0000 | [diff] [blame^] | 583 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 584 | /// EmitZeros - Emit a block of zeros. |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 585 | /// |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 586 | void AsmPrinter::EmitZeros(uint64_t NumZeros) const { |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 587 | if (NumZeros) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 588 | if (TAI->getZeroDirective()) { |
| 589 | O << TAI->getZeroDirective() << NumZeros; |
| 590 | if (TAI->getZeroDirectiveSuffix()) |
| 591 | O << TAI->getZeroDirectiveSuffix(); |
Jeff Cohen | c6a057b | 2006-05-02 03:46:13 +0000 | [diff] [blame] | 592 | O << "\n"; |
| 593 | } else { |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 594 | for (; NumZeros; --NumZeros) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 595 | O << TAI->getData8bitsDirective() << "0\n"; |
Chris Lattner | 7d057a3 | 2004-08-17 21:38:40 +0000 | [diff] [blame] | 596 | } |
| 597 | } |
| 598 | } |
| 599 | |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 600 | // Print out the specified constant, without a storage class. Only the |
| 601 | // constants valid in constant expressions can occur here. |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 602 | void AsmPrinter::EmitConstantValueOnly(const Constant *CV) { |
Chris Lattner | bd1d382 | 2004-10-16 18:19:26 +0000 | [diff] [blame] | 603 | if (CV->isNullValue() || isa<UndefValue>(CV)) |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 604 | O << "0"; |
Zhou Sheng | 6b6b6ef | 2007-01-11 12:24:14 +0000 | [diff] [blame] | 605 | else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { |
Chris Lattner | a875df3 | 2007-01-12 18:15:09 +0000 | [diff] [blame] | 606 | O << CI->getZExtValue(); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 607 | } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) { |
Duraid Madina | 855a519 | 2005-04-02 12:21:51 +0000 | [diff] [blame] | 608 | // This is a constant address for a global variable or function. Use the |
| 609 | // name of the variable or function as the address value, possibly |
| 610 | // decorating it with GlobalVarAddrPrefix/Suffix or |
| 611 | // FunctionAddrPrefix/Suffix (these all default to "" ) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 612 | if (isa<Function>(GV)) { |
| 613 | O << TAI->getFunctionAddrPrefix() |
| 614 | << Mang->getValueName(GV) |
| 615 | << TAI->getFunctionAddrSuffix(); |
| 616 | } else { |
| 617 | O << TAI->getGlobalVarAddrPrefix() |
| 618 | << Mang->getValueName(GV) |
| 619 | << TAI->getGlobalVarAddrSuffix(); |
| 620 | } |
Duraid Madina | 855a519 | 2005-04-02 12:21:51 +0000 | [diff] [blame] | 621 | } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 622 | const TargetData *TD = TM.getTargetData(); |
Anton Korobeynikov | 13b7d3d | 2007-02-04 23:27:42 +0000 | [diff] [blame] | 623 | unsigned Opcode = CE->getOpcode(); |
| 624 | switch (Opcode) { |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 625 | case Instruction::GetElementPtr: { |
| 626 | // generate a symbolic expression for the byte address |
| 627 | const Constant *ptrVal = CE->getOperand(0); |
Chris Lattner | 7f6b9d2 | 2007-02-10 20:31:59 +0000 | [diff] [blame] | 628 | SmallVector<Value*, 8> idxVec(CE->op_begin()+1, CE->op_end()); |
| 629 | if (int64_t Offset = TD->getIndexedOffset(ptrVal->getType(), &idxVec[0], |
| 630 | idxVec.size())) { |
Chris Lattner | 27e1921 | 2005-02-14 21:40:26 +0000 | [diff] [blame] | 631 | if (Offset) |
| 632 | O << "("; |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 633 | EmitConstantValueOnly(ptrVal); |
Chris Lattner | 27e1921 | 2005-02-14 21:40:26 +0000 | [diff] [blame] | 634 | if (Offset > 0) |
| 635 | O << ") + " << Offset; |
| 636 | else if (Offset < 0) |
| 637 | O << ") - " << -Offset; |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 638 | } else { |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 639 | EmitConstantValueOnly(ptrVal); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 640 | } |
| 641 | break; |
| 642 | } |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame] | 643 | case Instruction::Trunc: |
| 644 | case Instruction::ZExt: |
| 645 | case Instruction::SExt: |
| 646 | case Instruction::FPTrunc: |
| 647 | case Instruction::FPExt: |
| 648 | case Instruction::UIToFP: |
| 649 | case Instruction::SIToFP: |
| 650 | case Instruction::FPToUI: |
| 651 | case Instruction::FPToSI: |
| 652 | assert(0 && "FIXME: Don't yet support this kind of constant cast expr"); |
| 653 | break; |
Chris Lattner | cb0a681 | 2006-12-12 05:14:13 +0000 | [diff] [blame] | 654 | case Instruction::BitCast: |
| 655 | return EmitConstantValueOnly(CE->getOperand(0)); |
| 656 | |
Chris Lattner | ddc9401 | 2006-12-12 05:18:19 +0000 | [diff] [blame] | 657 | case Instruction::IntToPtr: { |
| 658 | // Handle casts to pointers by changing them into casts to the appropriate |
| 659 | // integer type. This promotes constant folding and simplifies this code. |
| 660 | Constant *Op = CE->getOperand(0); |
| 661 | Op = ConstantExpr::getIntegerCast(Op, TD->getIntPtrType(), false/*ZExt*/); |
| 662 | return EmitConstantValueOnly(Op); |
| 663 | } |
| 664 | |
| 665 | |
| 666 | case Instruction::PtrToInt: { |
Chris Lattner | 4a6bd33 | 2006-07-29 01:57:19 +0000 | [diff] [blame] | 667 | // Support only foldable casts to/from pointers that can be eliminated by |
| 668 | // changing the pointer to the appropriately sized integer type. |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 669 | Constant *Op = CE->getOperand(0); |
Chris Lattner | ddc9401 | 2006-12-12 05:18:19 +0000 | [diff] [blame] | 670 | const Type *Ty = CE->getType(); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 671 | |
Chris Lattner | ddc9401 | 2006-12-12 05:18:19 +0000 | [diff] [blame] | 672 | // We can emit the pointer value into this slot if the slot is an |
| 673 | // integer slot greater or equal to the size of the pointer. |
Chris Lattner | 42a7551 | 2007-01-15 02:27:26 +0000 | [diff] [blame] | 674 | if (Ty->isInteger() && |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 675 | TD->getTypeSize(Ty) >= TD->getTypeSize(Op->getType())) |
Chris Lattner | 4a6bd33 | 2006-07-29 01:57:19 +0000 | [diff] [blame] | 676 | return EmitConstantValueOnly(Op); |
Chris Lattner | 4a6bd33 | 2006-07-29 01:57:19 +0000 | [diff] [blame] | 677 | |
| 678 | assert(0 && "FIXME: Don't yet support this kind of constant cast expr"); |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 679 | EmitConstantValueOnly(Op); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 680 | break; |
| 681 | } |
| 682 | case Instruction::Add: |
Anton Korobeynikov | 13b7d3d | 2007-02-04 23:27:42 +0000 | [diff] [blame] | 683 | case Instruction::Sub: |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 684 | O << "("; |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 685 | EmitConstantValueOnly(CE->getOperand(0)); |
Anton Korobeynikov | 13b7d3d | 2007-02-04 23:27:42 +0000 | [diff] [blame] | 686 | O << (Opcode==Instruction::Add ? ") + (" : ") - ("); |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 687 | EmitConstantValueOnly(CE->getOperand(1)); |
Chris Lattner | a80ba71 | 2004-08-16 23:15:22 +0000 | [diff] [blame] | 688 | O << ")"; |
| 689 | break; |
| 690 | default: |
| 691 | assert(0 && "Unsupported operator!"); |
| 692 | } |
| 693 | } else { |
| 694 | assert(0 && "Unknown constant value!"); |
| 695 | } |
| 696 | } |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 697 | |
Chris Lattner | 2980cef | 2005-11-10 18:06:33 +0000 | [diff] [blame] | 698 | /// printAsCString - Print the specified array as a C compatible string, only if |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 699 | /// the predicate isString is true. |
| 700 | /// |
Chris Lattner | 2980cef | 2005-11-10 18:06:33 +0000 | [diff] [blame] | 701 | static void printAsCString(std::ostream &O, const ConstantArray *CVA, |
| 702 | unsigned LastElt) { |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 703 | assert(CVA->isString() && "Array is not string compatible!"); |
| 704 | |
| 705 | O << "\""; |
Chris Lattner | 2980cef | 2005-11-10 18:06:33 +0000 | [diff] [blame] | 706 | for (unsigned i = 0; i != LastElt; ++i) { |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 707 | unsigned char C = |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 708 | (unsigned char)cast<ConstantInt>(CVA->getOperand(i))->getZExtValue(); |
Jim Laskey | f1cdea1 | 2007-01-25 15:12:02 +0000 | [diff] [blame] | 709 | printStringChar(O, C); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 710 | } |
| 711 | O << "\""; |
| 712 | } |
| 713 | |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 714 | /// EmitString - Emit a zero-byte-terminated string constant. |
| 715 | /// |
| 716 | void AsmPrinter::EmitString(const ConstantArray *CVA) const { |
| 717 | unsigned NumElts = CVA->getNumOperands(); |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 718 | if (TAI->getAscizDirective() && NumElts && |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 719 | cast<ConstantInt>(CVA->getOperand(NumElts-1))->getZExtValue() == 0) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 720 | O << TAI->getAscizDirective(); |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 721 | printAsCString(O, CVA, NumElts-1); |
| 722 | } else { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 723 | O << TAI->getAsciiDirective(); |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 724 | printAsCString(O, CVA, NumElts); |
| 725 | } |
| 726 | O << "\n"; |
| 727 | } |
| 728 | |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 729 | /// EmitGlobalConstant - Print a general LLVM constant to the .s file. |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 730 | /// |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 731 | void AsmPrinter::EmitGlobalConstant(const Constant *CV) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 732 | const TargetData *TD = TM.getTargetData(); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 733 | |
Chris Lattner | bd1d382 | 2004-10-16 18:19:26 +0000 | [diff] [blame] | 734 | if (CV->isNullValue() || isa<UndefValue>(CV)) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 735 | EmitZeros(TD->getTypeSize(CV->getType())); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 736 | return; |
| 737 | } else if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) { |
| 738 | if (CVA->isString()) { |
Jeff Cohen | c884db4 | 2006-05-02 01:16:28 +0000 | [diff] [blame] | 739 | EmitString(CVA); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 740 | } else { // Not a string. Print the values in successive locations |
| 741 | for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i) |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 742 | EmitGlobalConstant(CVA->getOperand(i)); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 743 | } |
| 744 | return; |
| 745 | } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) { |
| 746 | // Print the fields in successive locations. Pad to align if needed! |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 747 | const StructLayout *cvsLayout = TD->getStructLayout(CVS->getType()); |
Chris Lattner | dea18b6 | 2005-01-08 19:59:10 +0000 | [diff] [blame] | 748 | uint64_t sizeSoFar = 0; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 749 | for (unsigned i = 0, e = CVS->getNumOperands(); i != e; ++i) { |
| 750 | const Constant* field = CVS->getOperand(i); |
| 751 | |
| 752 | // Check if padding is needed and insert one or more 0s. |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 753 | uint64_t fieldSize = TD->getTypeSize(field->getType()); |
Chris Lattner | b0c39a3 | 2007-02-10 19:59:22 +0000 | [diff] [blame] | 754 | uint64_t padSize = ((i == e-1? cvsLayout->getSizeInBytes() |
Chris Lattner | b1919e2 | 2007-02-10 19:55:17 +0000 | [diff] [blame] | 755 | : cvsLayout->getElementOffset(i+1)) |
| 756 | - cvsLayout->getElementOffset(i)) - fieldSize; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 757 | sizeSoFar += fieldSize + padSize; |
| 758 | |
| 759 | // Now print the actual field value |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 760 | EmitGlobalConstant(field); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 761 | |
| 762 | // Insert the field padding unless it's zero bytes... |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 763 | EmitZeros(padSize); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 764 | } |
Chris Lattner | b0c39a3 | 2007-02-10 19:59:22 +0000 | [diff] [blame] | 765 | assert(sizeSoFar == cvsLayout->getSizeInBytes() && |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 766 | "Layout of constant struct may be incorrect!"); |
| 767 | return; |
| 768 | } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) { |
| 769 | // FP Constants are printed as integer constants to avoid losing |
| 770 | // precision... |
| 771 | double Val = CFP->getValue(); |
| 772 | if (CFP->getType() == Type::DoubleTy) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 773 | if (TAI->getData64bitsDirective()) |
| 774 | O << TAI->getData64bitsDirective() << DoubleToBits(Val) << "\t" |
| 775 | << TAI->getCommentString() << " double value: " << Val << "\n"; |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 776 | else if (TD->isBigEndian()) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 777 | O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32) |
| 778 | << "\t" << TAI->getCommentString() |
| 779 | << " double most significant word " << Val << "\n"; |
| 780 | O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val)) |
| 781 | << "\t" << TAI->getCommentString() |
| 782 | << " double least significant word " << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 783 | } else { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 784 | O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val)) |
| 785 | << "\t" << TAI->getCommentString() |
| 786 | << " double least significant word " << Val << "\n"; |
| 787 | O << TAI->getData32bitsDirective() << unsigned(DoubleToBits(Val) >> 32) |
| 788 | << "\t" << TAI->getCommentString() |
| 789 | << " double most significant word " << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 790 | } |
| 791 | return; |
| 792 | } else { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 793 | O << TAI->getData32bitsDirective() << FloatToBits(Val) |
| 794 | << "\t" << TAI->getCommentString() << " float " << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 795 | return; |
| 796 | } |
Reid Spencer | 4785781 | 2006-12-31 05:55:36 +0000 | [diff] [blame] | 797 | } else if (CV->getType() == Type::Int64Ty) { |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 798 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 799 | uint64_t Val = CI->getZExtValue(); |
Misha Brukman | edf128a | 2005-04-21 22:36:52 +0000 | [diff] [blame] | 800 | |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 801 | if (TAI->getData64bitsDirective()) |
| 802 | O << TAI->getData64bitsDirective() << Val << "\n"; |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 803 | else if (TD->isBigEndian()) { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 804 | O << TAI->getData32bitsDirective() << unsigned(Val >> 32) |
| 805 | << "\t" << TAI->getCommentString() |
| 806 | << " Double-word most significant word " << Val << "\n"; |
| 807 | O << TAI->getData32bitsDirective() << unsigned(Val) |
| 808 | << "\t" << TAI->getCommentString() |
| 809 | << " Double-word least significant word " << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 810 | } else { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 811 | O << TAI->getData32bitsDirective() << unsigned(Val) |
| 812 | << "\t" << TAI->getCommentString() |
| 813 | << " Double-word least significant word " << Val << "\n"; |
| 814 | O << TAI->getData32bitsDirective() << unsigned(Val >> 32) |
| 815 | << "\t" << TAI->getCommentString() |
| 816 | << " Double-word most significant word " << Val << "\n"; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 817 | } |
| 818 | return; |
| 819 | } |
Reid Spencer | 9d6565a | 2007-02-15 02:26:10 +0000 | [diff] [blame] | 820 | } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CV)) { |
| 821 | const VectorType *PTy = CP->getType(); |
Nate Begeman | 8cfa57b | 2005-12-06 06:18:55 +0000 | [diff] [blame] | 822 | |
| 823 | for (unsigned I = 0, E = PTy->getNumElements(); I < E; ++I) |
| 824 | EmitGlobalConstant(CP->getOperand(I)); |
| 825 | |
| 826 | return; |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 827 | } |
| 828 | |
| 829 | const Type *type = CV->getType(); |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 830 | printDataDirective(type); |
Chris Lattner | 25045bd | 2005-11-21 07:51:36 +0000 | [diff] [blame] | 831 | EmitConstantValueOnly(CV); |
Chris Lattner | 1b7e235 | 2004-08-17 06:36:49 +0000 | [diff] [blame] | 832 | O << "\n"; |
| 833 | } |
Chris Lattner | 0264d1a | 2006-01-27 02:10:10 +0000 | [diff] [blame] | 834 | |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 835 | void |
| 836 | AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { |
| 837 | // Target doesn't support this yet! |
| 838 | abort(); |
| 839 | } |
| 840 | |
Chris Lattner | 3ce9b67 | 2006-09-26 23:59:50 +0000 | [diff] [blame] | 841 | /// PrintSpecial - Print information related to the specified machine instr |
| 842 | /// that is independent of the operand, and may be independent of the instr |
| 843 | /// itself. This can be useful for portably encoding the comment character |
| 844 | /// or other bits of target-specific knowledge into the asmstrings. The |
| 845 | /// syntax used is ${:comment}. Targets can override this to add support |
| 846 | /// for their own strange codes. |
| 847 | void AsmPrinter::PrintSpecial(const MachineInstr *MI, const char *Code) { |
Chris Lattner | bae02cf | 2006-09-27 00:06:07 +0000 | [diff] [blame] | 848 | if (!strcmp(Code, "private")) { |
| 849 | O << TAI->getPrivateGlobalPrefix(); |
| 850 | } else if (!strcmp(Code, "comment")) { |
Chris Lattner | 3ce9b67 | 2006-09-26 23:59:50 +0000 | [diff] [blame] | 851 | O << TAI->getCommentString(); |
| 852 | } else if (!strcmp(Code, "uid")) { |
| 853 | // Assign a unique ID to this machine instruction. |
| 854 | static const MachineInstr *LastMI = 0; |
Chris Lattner | b6a24bf | 2007-02-05 21:23:52 +0000 | [diff] [blame] | 855 | static const Function *F = 0; |
Chris Lattner | 3ce9b67 | 2006-09-26 23:59:50 +0000 | [diff] [blame] | 856 | static unsigned Counter = 0U-1; |
Chris Lattner | b6a24bf | 2007-02-05 21:23:52 +0000 | [diff] [blame] | 857 | |
| 858 | // Comparing the address of MI isn't sufficient, because machineinstrs may |
| 859 | // be allocated to the same address across functions. |
| 860 | const Function *ThisF = MI->getParent()->getParent()->getFunction(); |
| 861 | |
Chris Lattner | 3ce9b67 | 2006-09-26 23:59:50 +0000 | [diff] [blame] | 862 | // If this is a new machine instruction, bump the counter. |
Chris Lattner | b6a24bf | 2007-02-05 21:23:52 +0000 | [diff] [blame] | 863 | if (LastMI != MI || F != ThisF) { |
| 864 | ++Counter; |
| 865 | LastMI = MI; |
Chris Lattner | 4b09252 | 2007-02-06 01:56:31 +0000 | [diff] [blame] | 866 | F = ThisF; |
Chris Lattner | b6a24bf | 2007-02-05 21:23:52 +0000 | [diff] [blame] | 867 | } |
Chris Lattner | 3ce9b67 | 2006-09-26 23:59:50 +0000 | [diff] [blame] | 868 | O << Counter; |
| 869 | } else { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 870 | cerr << "Unknown special formatter '" << Code |
| 871 | << "' for machine instr: " << *MI; |
Chris Lattner | 3ce9b67 | 2006-09-26 23:59:50 +0000 | [diff] [blame] | 872 | exit(1); |
| 873 | } |
| 874 | } |
| 875 | |
| 876 | |
Chris Lattner | 0264d1a | 2006-01-27 02:10:10 +0000 | [diff] [blame] | 877 | /// printInlineAsm - This method formats and prints the specified machine |
| 878 | /// instruction that is an inline asm. |
| 879 | void AsmPrinter::printInlineAsm(const MachineInstr *MI) const { |
Chris Lattner | f2b67cf | 2006-01-30 23:00:08 +0000 | [diff] [blame] | 880 | unsigned NumOperands = MI->getNumOperands(); |
| 881 | |
| 882 | // Count the number of register definitions. |
| 883 | unsigned NumDefs = 0; |
Chris Lattner | 67942f5 | 2006-09-05 20:02:51 +0000 | [diff] [blame] | 884 | for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef(); |
| 885 | ++NumDefs) |
Chris Lattner | f2b67cf | 2006-01-30 23:00:08 +0000 | [diff] [blame] | 886 | assert(NumDefs != NumOperands-1 && "No asm string?"); |
| 887 | |
| 888 | assert(MI->getOperand(NumDefs).isExternalSymbol() && "No asm string?"); |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 889 | |
| 890 | // Disassemble the AsmStr, printing out the literal pieces, the operands, etc. |
Chris Lattner | f2b67cf | 2006-01-30 23:00:08 +0000 | [diff] [blame] | 891 | const char *AsmStr = MI->getOperand(NumDefs).getSymbolName(); |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 892 | |
Chris Lattner | f26f5dd | 2006-07-28 00:17:20 +0000 | [diff] [blame] | 893 | // If this asmstr is empty, don't bother printing the #APP/#NOAPP markers. |
| 894 | if (AsmStr[0] == 0) { |
| 895 | O << "\n"; // Tab already printed, avoid double indenting next instr. |
| 896 | return; |
| 897 | } |
| 898 | |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 899 | O << TAI->getInlineAsmStart() << "\n\t"; |
Chris Lattner | f26f5dd | 2006-07-28 00:17:20 +0000 | [diff] [blame] | 900 | |
Bill Wendling | eb9a42c | 2007-01-16 03:42:04 +0000 | [diff] [blame] | 901 | // The variant of the current asmprinter. |
| 902 | int AsmPrinterVariant = TAI->getAssemblerDialect(); |
| 903 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 904 | int CurVariant = -1; // The number of the {.|.|.} region we are in. |
| 905 | const char *LastEmitted = AsmStr; // One past the last character emitted. |
Chris Lattner | 2cc2f66 | 2006-02-01 01:28:23 +0000 | [diff] [blame] | 906 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 907 | while (*LastEmitted) { |
| 908 | switch (*LastEmitted) { |
| 909 | default: { |
| 910 | // Not a special case, emit the string section literally. |
| 911 | const char *LiteralEnd = LastEmitted+1; |
| 912 | while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 913 | *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 914 | ++LiteralEnd; |
| 915 | if (CurVariant == -1 || CurVariant == AsmPrinterVariant) |
| 916 | O.write(LastEmitted, LiteralEnd-LastEmitted); |
| 917 | LastEmitted = LiteralEnd; |
| 918 | break; |
| 919 | } |
Chris Lattner | 1c05997 | 2006-05-05 21:47:05 +0000 | [diff] [blame] | 920 | case '\n': |
| 921 | ++LastEmitted; // Consume newline character. |
| 922 | O << "\n\t"; // Indent code with newline. |
| 923 | break; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 924 | case '$': { |
| 925 | ++LastEmitted; // Consume '$' character. |
Chris Lattner | faf1dae | 2006-10-03 23:27:09 +0000 | [diff] [blame] | 926 | bool Done = true; |
| 927 | |
| 928 | // Handle escapes. |
| 929 | switch (*LastEmitted) { |
| 930 | default: Done = false; break; |
| 931 | case '$': // $$ -> $ |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 932 | if (CurVariant == -1 || CurVariant == AsmPrinterVariant) |
| 933 | O << '$'; |
| 934 | ++LastEmitted; // Consume second '$' character. |
| 935 | break; |
Chris Lattner | faf1dae | 2006-10-03 23:27:09 +0000 | [diff] [blame] | 936 | case '(': // $( -> same as GCC's { character. |
| 937 | ++LastEmitted; // Consume '(' character. |
| 938 | if (CurVariant != -1) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 939 | cerr << "Nested variants found in inline asm string: '" |
| 940 | << AsmStr << "'\n"; |
Chris Lattner | faf1dae | 2006-10-03 23:27:09 +0000 | [diff] [blame] | 941 | exit(1); |
| 942 | } |
| 943 | CurVariant = 0; // We're in the first variant now. |
| 944 | break; |
| 945 | case '|': |
| 946 | ++LastEmitted; // consume '|' character. |
| 947 | if (CurVariant == -1) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 948 | cerr << "Found '|' character outside of variant in inline asm " |
| 949 | << "string: '" << AsmStr << "'\n"; |
Chris Lattner | faf1dae | 2006-10-03 23:27:09 +0000 | [diff] [blame] | 950 | exit(1); |
| 951 | } |
| 952 | ++CurVariant; // We're in the next variant. |
| 953 | break; |
| 954 | case ')': // $) -> same as GCC's } char. |
| 955 | ++LastEmitted; // consume ')' character. |
| 956 | if (CurVariant == -1) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 957 | cerr << "Found '}' character outside of variant in inline asm " |
| 958 | << "string: '" << AsmStr << "'\n"; |
Chris Lattner | faf1dae | 2006-10-03 23:27:09 +0000 | [diff] [blame] | 959 | exit(1); |
| 960 | } |
| 961 | CurVariant = -1; |
| 962 | break; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 963 | } |
Chris Lattner | faf1dae | 2006-10-03 23:27:09 +0000 | [diff] [blame] | 964 | if (Done) break; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 965 | |
| 966 | bool HasCurlyBraces = false; |
| 967 | if (*LastEmitted == '{') { // ${variable} |
| 968 | ++LastEmitted; // Consume '{' character. |
| 969 | HasCurlyBraces = true; |
| 970 | } |
| 971 | |
| 972 | const char *IDStart = LastEmitted; |
| 973 | char *IDEnd; |
Chris Lattner | fad2912 | 2007-01-23 00:36:17 +0000 | [diff] [blame] | 974 | errno = 0; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 975 | long Val = strtol(IDStart, &IDEnd, 10); // We only accept numbers for IDs. |
| 976 | if (!isdigit(*IDStart) || (Val == 0 && errno == EINVAL)) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 977 | cerr << "Bad $ operand number in inline asm string: '" |
| 978 | << AsmStr << "'\n"; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 979 | exit(1); |
| 980 | } |
| 981 | LastEmitted = IDEnd; |
| 982 | |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 983 | char Modifier[2] = { 0, 0 }; |
| 984 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 985 | if (HasCurlyBraces) { |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 986 | // If we have curly braces, check for a modifier character. This |
| 987 | // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm. |
| 988 | if (*LastEmitted == ':') { |
| 989 | ++LastEmitted; // Consume ':' character. |
| 990 | if (*LastEmitted == 0) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 991 | cerr << "Bad ${:} expression in inline asm string: '" |
| 992 | << AsmStr << "'\n"; |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 993 | exit(1); |
| 994 | } |
| 995 | |
| 996 | Modifier[0] = *LastEmitted; |
| 997 | ++LastEmitted; // Consume modifier character. |
| 998 | } |
| 999 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1000 | if (*LastEmitted != '}') { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 1001 | cerr << "Bad ${} expression in inline asm string: '" |
| 1002 | << AsmStr << "'\n"; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1003 | exit(1); |
| 1004 | } |
| 1005 | ++LastEmitted; // Consume '}' character. |
| 1006 | } |
| 1007 | |
| 1008 | if ((unsigned)Val >= NumOperands-1) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 1009 | cerr << "Invalid $ operand number in inline asm string: '" |
| 1010 | << AsmStr << "'\n"; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1011 | exit(1); |
| 1012 | } |
| 1013 | |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 1014 | // 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] | 1015 | // operand! |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 1016 | if (CurVariant == -1 || CurVariant == AsmPrinterVariant) { |
| 1017 | unsigned OpNo = 1; |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 1018 | |
| 1019 | bool Error = false; |
| 1020 | |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 1021 | // Scan to find the machine operand number for the operand. |
Chris Lattner | daf6bc6 | 2006-02-24 19:50:58 +0000 | [diff] [blame] | 1022 | for (; Val; --Val) { |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 1023 | if (OpNo >= MI->getNumOperands()) break; |
Chris Lattner | daf6bc6 | 2006-02-24 19:50:58 +0000 | [diff] [blame] | 1024 | unsigned OpFlags = MI->getOperand(OpNo).getImmedValue(); |
| 1025 | OpNo += (OpFlags >> 3) + 1; |
| 1026 | } |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 1027 | |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 1028 | if (OpNo >= MI->getNumOperands()) { |
| 1029 | Error = true; |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 1030 | } else { |
Chris Lattner | fd561cd | 2006-06-08 18:00:47 +0000 | [diff] [blame] | 1031 | unsigned OpFlags = MI->getOperand(OpNo).getImmedValue(); |
| 1032 | ++OpNo; // Skip over the ID number. |
| 1033 | |
| 1034 | AsmPrinter *AP = const_cast<AsmPrinter*>(this); |
| 1035 | if ((OpFlags & 7) == 4 /*ADDR MODE*/) { |
| 1036 | Error = AP->PrintAsmMemoryOperand(MI, OpNo, AsmPrinterVariant, |
| 1037 | Modifier[0] ? Modifier : 0); |
| 1038 | } else { |
| 1039 | Error = AP->PrintAsmOperand(MI, OpNo, AsmPrinterVariant, |
| 1040 | Modifier[0] ? Modifier : 0); |
| 1041 | } |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 1042 | } |
| 1043 | if (Error) { |
Bill Wendling | e815619 | 2006-12-07 01:30:32 +0000 | [diff] [blame] | 1044 | cerr << "Invalid operand found in inline asm: '" |
| 1045 | << AsmStr << "'\n"; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1046 | MI->dump(); |
| 1047 | exit(1); |
| 1048 | } |
Chris Lattner | c3a9f8d | 2006-02-23 19:21:04 +0000 | [diff] [blame] | 1049 | } |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1050 | break; |
| 1051 | } |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1052 | } |
| 1053 | } |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 1054 | O << "\n\t" << TAI->getInlineAsmEnd() << "\n"; |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1055 | } |
| 1056 | |
Jim Laskey | 1ee2925 | 2007-01-26 14:34:52 +0000 | [diff] [blame] | 1057 | /// printLabel - This method prints a local label used by debug and |
| 1058 | /// exception handling tables. |
| 1059 | void AsmPrinter::printLabel(const MachineInstr *MI) const { |
Jim Laskey | b82313f | 2007-02-01 16:31:34 +0000 | [diff] [blame] | 1060 | O << "\n" |
| 1061 | << TAI->getPrivateGlobalPrefix() |
Jim Laskey | 29bf16a | 2007-02-01 17:46:10 +0000 | [diff] [blame] | 1062 | << "label_" |
Jim Laskey | 1ee2925 | 2007-01-26 14:34:52 +0000 | [diff] [blame] | 1063 | << MI->getOperand(0).getImmedValue() |
| 1064 | << ":\n"; |
| 1065 | } |
| 1066 | |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1067 | /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM |
| 1068 | /// instruction, using the specified assembler variant. Targets should |
| 1069 | /// overried this to format as appropriate. |
| 1070 | bool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
Chris Lattner | a36cb0a | 2006-02-06 22:17:23 +0000 | [diff] [blame] | 1071 | unsigned AsmVariant, const char *ExtraCode) { |
Chris Lattner | 6609913 | 2006-02-01 22:41:11 +0000 | [diff] [blame] | 1072 | // Target doesn't support this yet! |
| 1073 | return true; |
Chris Lattner | 0264d1a | 2006-01-27 02:10:10 +0000 | [diff] [blame] | 1074 | } |
Chris Lattner | dd26033 | 2006-02-24 20:21:58 +0000 | [diff] [blame] | 1075 | |
| 1076 | bool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, |
| 1077 | unsigned AsmVariant, |
| 1078 | const char *ExtraCode) { |
| 1079 | // Target doesn't support this yet! |
| 1080 | return true; |
| 1081 | } |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 1082 | |
| 1083 | /// printBasicBlockLabel - This method prints the label for the specified |
| 1084 | /// MachineBasicBlock |
Nate Begeman | cdf38c4 | 2006-05-02 05:37:32 +0000 | [diff] [blame] | 1085 | void AsmPrinter::printBasicBlockLabel(const MachineBasicBlock *MBB, |
| 1086 | bool printColon, |
| 1087 | bool printComment) const { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 1088 | O << TAI->getPrivateGlobalPrefix() << "BB" << FunctionNumber << "_" |
Nate Begeman | 9d51eeb | 2006-05-02 17:36:46 +0000 | [diff] [blame] | 1089 | << MBB->getNumber(); |
Nate Begeman | cdf38c4 | 2006-05-02 05:37:32 +0000 | [diff] [blame] | 1090 | if (printColon) |
| 1091 | O << ':'; |
Chris Lattner | 9c78ecb | 2006-10-05 21:40:14 +0000 | [diff] [blame] | 1092 | if (printComment && MBB->getBasicBlock()) |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 1093 | O << '\t' << TAI->getCommentString() << MBB->getBasicBlock()->getName(); |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 1094 | } |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 1095 | |
| 1096 | /// printSetLabel - This method prints a set label for the specified |
| 1097 | /// MachineBasicBlock |
| 1098 | void AsmPrinter::printSetLabel(unsigned uid, |
| 1099 | const MachineBasicBlock *MBB) const { |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 1100 | if (!TAI->getSetDirective()) |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 1101 | return; |
| 1102 | |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 1103 | O << TAI->getSetDirective() << ' ' << TAI->getPrivateGlobalPrefix() |
| 1104 | << getFunctionNumber() << '_' << uid << "_set_" << MBB->getNumber() << ','; |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 1105 | printBasicBlockLabel(MBB, false, false); |
Jim Laskey | 563321a | 2006-09-06 18:34:40 +0000 | [diff] [blame] | 1106 | O << '-' << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() |
Nate Begeman | 52a51e38 | 2006-08-12 21:29:52 +0000 | [diff] [blame] | 1107 | << '_' << uid << '\n'; |
| 1108 | } |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 1109 | |
Evan Cheng | 41349c1 | 2006-11-01 09:23:08 +0000 | [diff] [blame] | 1110 | void AsmPrinter::printSetLabel(unsigned uid, unsigned uid2, |
| 1111 | const MachineBasicBlock *MBB) const { |
| 1112 | if (!TAI->getSetDirective()) |
| 1113 | return; |
| 1114 | |
| 1115 | O << TAI->getSetDirective() << ' ' << TAI->getPrivateGlobalPrefix() |
| 1116 | << getFunctionNumber() << '_' << uid << '_' << uid2 |
| 1117 | << "_set_" << MBB->getNumber() << ','; |
| 1118 | printBasicBlockLabel(MBB, false, false); |
| 1119 | O << '-' << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() |
| 1120 | << '_' << uid << '_' << uid2 << '\n'; |
| 1121 | } |
| 1122 | |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 1123 | /// printDataDirective - This method prints the asm directive for the |
| 1124 | /// specified type. |
| 1125 | void AsmPrinter::printDataDirective(const Type *type) { |
| 1126 | const TargetData *TD = TM.getTargetData(); |
| 1127 | switch (type->getTypeID()) { |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 1128 | case Type::IntegerTyID: { |
| 1129 | unsigned BitWidth = cast<IntegerType>(type)->getBitWidth(); |
| 1130 | if (BitWidth <= 8) |
| 1131 | O << TAI->getData8bitsDirective(); |
| 1132 | else if (BitWidth <= 16) |
| 1133 | O << TAI->getData16bitsDirective(); |
| 1134 | else if (BitWidth <= 32) |
| 1135 | O << TAI->getData32bitsDirective(); |
| 1136 | else if (BitWidth <= 64) { |
| 1137 | assert(TAI->getData64bitsDirective() && |
| 1138 | "Target cannot handle 64-bit constant exprs!"); |
| 1139 | O << TAI->getData64bitsDirective(); |
| 1140 | } |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 1141 | break; |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 1142 | } |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 1143 | case Type::PointerTyID: |
| 1144 | if (TD->getPointerSize() == 8) { |
| 1145 | assert(TAI->getData64bitsDirective() && |
| 1146 | "Target cannot handle 64-bit pointer exprs!"); |
| 1147 | O << TAI->getData64bitsDirective(); |
Reid Spencer | a54b7cb | 2007-01-12 07:05:14 +0000 | [diff] [blame] | 1148 | } else { |
| 1149 | O << TAI->getData32bitsDirective(); |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 1150 | } |
Evan Cheng | d6594ae | 2006-09-12 21:00:35 +0000 | [diff] [blame] | 1151 | break; |
| 1152 | case Type::FloatTyID: case Type::DoubleTyID: |
| 1153 | assert (0 && "Should have already output floating point constant."); |
| 1154 | default: |
| 1155 | assert (0 && "Can't handle printing this type of thing"); |
| 1156 | break; |
| 1157 | } |
| 1158 | } |
Dale Johannesen | 4c3a5f8 | 2007-02-16 01:54:53 +0000 | [diff] [blame] | 1159 | |