Nate Begeman | 21e463b | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 1 | //===-- PPCAsmPrinter.cpp - Print machine instrs to PowerPC assembly --------=// |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 2 | // |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 7 | // |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Misha Brukman | 05fcd0c | 2004-07-08 17:58:04 +0000 | [diff] [blame] | 10 | // This file contains a printer that converts from our internal representation |
| 11 | // of machine-dependent LLVM code to PowerPC assembly language. This printer is |
Chris Lattner | 83660c5 | 2004-07-28 20:18:53 +0000 | [diff] [blame] | 12 | // the output mechanism used by `llc'. |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 13 | // |
Misha Brukman | 05fcd0c | 2004-07-08 17:58:04 +0000 | [diff] [blame] | 14 | // Documentation at http://developer.apple.com/documentation/DeveloperTools/ |
| 15 | // Reference/Assembler/ASMIntroduction/chapter_1_section_1.html |
Misha Brukman | 218bec7 | 2004-06-29 17:13:26 +0000 | [diff] [blame] | 16 | // |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 17 | //===----------------------------------------------------------------------===// |
| 18 | |
Misha Brukman | 0579449 | 2004-06-24 17:31:42 +0000 | [diff] [blame] | 19 | #define DEBUG_TYPE "asmprinter" |
Chris Lattner | 2668959 | 2005-10-14 23:51:18 +0000 | [diff] [blame] | 20 | #include "PPC.h" |
Chris Lattner | df4ed63 | 2006-11-17 22:10:59 +0000 | [diff] [blame] | 21 | #include "PPCPredicates.h" |
Chris Lattner | 16e71f2 | 2005-10-14 23:59:06 +0000 | [diff] [blame] | 22 | #include "PPCTargetMachine.h" |
Chris Lattner | 2668959 | 2005-10-14 23:51:18 +0000 | [diff] [blame] | 23 | #include "PPCSubtarget.h" |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 24 | #include "llvm/Constants.h" |
| 25 | #include "llvm/DerivedTypes.h" |
| 26 | #include "llvm/Module.h" |
| 27 | #include "llvm/Assembly/Writer.h" |
Chris Lattner | a384079 | 2004-08-16 23:25:21 +0000 | [diff] [blame] | 28 | #include "llvm/CodeGen/AsmPrinter.h" |
Jim Laskey | a7cea6f | 2006-01-04 13:52:30 +0000 | [diff] [blame] | 29 | #include "llvm/CodeGen/DwarfWriter.h" |
Misha Brukman | 0579449 | 2004-06-24 17:31:42 +0000 | [diff] [blame] | 30 | #include "llvm/CodeGen/MachineFunctionPass.h" |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 31 | #include "llvm/CodeGen/MachineInstr.h" |
Bill Wendling | 381802f | 2008-01-26 06:51:24 +0000 | [diff] [blame] | 32 | #include "llvm/CodeGen/MachineInstrBuilder.h" |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 33 | #include "llvm/CodeGen/MachineModuleInfoImpls.h" |
Chris Lattner | 325d3dc | 2009-09-13 17:14:04 +0000 | [diff] [blame] | 34 | #include "llvm/MC/MCAsmInfo.h" |
Chris Lattner | 0b4bad5 | 2010-01-13 19:00:57 +0000 | [diff] [blame] | 35 | #include "llvm/MC/MCContext.h" |
Chris Lattner | f9bdedd | 2009-08-10 18:15:01 +0000 | [diff] [blame] | 36 | #include "llvm/MC/MCSectionMachO.h" |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 37 | #include "llvm/MC/MCStreamer.h" |
Chris Lattner | 325d3dc | 2009-09-13 17:14:04 +0000 | [diff] [blame] | 38 | #include "llvm/MC/MCSymbol.h" |
Chris Lattner | 45111d1 | 2010-01-16 21:57:06 +0000 | [diff] [blame] | 39 | #include "llvm/Target/Mangler.h" |
Chris Lattner | a87dea4 | 2009-07-31 18:48:30 +0000 | [diff] [blame] | 40 | #include "llvm/Target/TargetLoweringObjectFile.h" |
| 41 | #include "llvm/Target/TargetRegisterInfo.h" |
| 42 | #include "llvm/Target/TargetInstrInfo.h" |
| 43 | #include "llvm/Target/TargetOptions.h" |
| 44 | #include "llvm/Target/TargetRegistry.h" |
Nate Begeman | a11c2e8 | 2004-09-04 14:51:26 +0000 | [diff] [blame] | 45 | #include "llvm/Support/MathExtras.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 46 | #include "llvm/Support/CommandLine.h" |
| 47 | #include "llvm/Support/Debug.h" |
Torok Edwin | dac237e | 2009-07-08 20:53:28 +0000 | [diff] [blame] | 48 | #include "llvm/Support/ErrorHandling.h" |
David Greene | 7184781 | 2009-07-14 20:18:05 +0000 | [diff] [blame] | 49 | #include "llvm/Support/FormattedStream.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 50 | #include "llvm/ADT/Statistic.h" |
| 51 | #include "llvm/ADT/StringExtras.h" |
Evan Cheng | ae94e59 | 2008-12-05 01:06:39 +0000 | [diff] [blame] | 52 | #include "llvm/ADT/StringSet.h" |
Chris Lattner | 4813035 | 2010-01-13 06:38:18 +0000 | [diff] [blame] | 53 | #include "llvm/ADT/SmallString.h" |
Chris Lattner | a384079 | 2004-08-16 23:25:21 +0000 | [diff] [blame] | 54 | using namespace llvm; |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 55 | |
Chris Lattner | 95b2c7d | 2006-12-19 22:59:26 +0000 | [diff] [blame] | 56 | STATISTIC(EmittedInsts, "Number of machine instrs printed"); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 57 | |
Chris Lattner | 95b2c7d | 2006-12-19 22:59:26 +0000 | [diff] [blame] | 58 | namespace { |
Nick Lewycky | 6726b6d | 2009-10-25 06:33:48 +0000 | [diff] [blame] | 59 | class PPCAsmPrinter : public AsmPrinter { |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 60 | protected: |
Chris Lattner | 9ec8fac | 2009-07-15 02:28:57 +0000 | [diff] [blame] | 61 | struct FnStubInfo { |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 62 | MCSymbol *Stub, *LazyPtr, *AnonSymbol; |
Chris Lattner | 9ec8fac | 2009-07-15 02:28:57 +0000 | [diff] [blame] | 63 | |
Chris Lattner | 0b4bad5 | 2010-01-13 19:00:57 +0000 | [diff] [blame] | 64 | FnStubInfo() { |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 65 | Stub = LazyPtr = AnonSymbol = 0; |
Chris Lattner | 0b4bad5 | 2010-01-13 19:00:57 +0000 | [diff] [blame] | 66 | } |
Chris Lattner | 9ec8fac | 2009-07-15 02:28:57 +0000 | [diff] [blame] | 67 | |
Chris Lattner | 76a3c48 | 2010-01-16 01:45:47 +0000 | [diff] [blame] | 68 | void Init(const GlobalValue *GV, AsmPrinter *Printer) { |
Chris Lattner | 9ec8fac | 2009-07-15 02:28:57 +0000 | [diff] [blame] | 69 | // Already initialized. |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 70 | if (Stub != 0) return; |
Chris Lattner | 59b34fe | 2010-01-13 19:05:36 +0000 | [diff] [blame] | 71 | |
| 72 | // Get the names. |
Chris Lattner | 7a2ba94 | 2010-01-16 18:37:32 +0000 | [diff] [blame] | 73 | Stub = Printer->GetSymbolWithGlobalValueBase(GV, "$stub"); |
| 74 | LazyPtr = Printer->GetSymbolWithGlobalValueBase(GV, "$lazy_ptr"); |
| 75 | AnonSymbol = Printer->GetSymbolWithGlobalValueBase(GV, "$stub$tmp"); |
Chris Lattner | 9ec8fac | 2009-07-15 02:28:57 +0000 | [diff] [blame] | 76 | } |
| 77 | |
Chris Lattner | 0b4bad5 | 2010-01-13 19:00:57 +0000 | [diff] [blame] | 78 | void Init(StringRef GVName, Mangler *Mang, MCContext &Ctx) { |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 79 | assert(!GVName.empty() && "external symbol name shouldn't be empty"); |
| 80 | if (Stub != 0) return; // Already initialized. |
Chris Lattner | ee9250b | 2010-01-13 07:56:59 +0000 | [diff] [blame] | 81 | // Get the names for the external symbol name. |
Chris Lattner | 4813035 | 2010-01-13 06:38:18 +0000 | [diff] [blame] | 82 | SmallString<128> TmpStr; |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 83 | Mang->getNameWithPrefix(TmpStr, GVName, Mangler::Private); |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 84 | TmpStr += "$stub"; |
| 85 | Stub = Ctx.GetOrCreateSymbol(TmpStr.str()); |
Chris Lattner | 59b34fe | 2010-01-13 19:05:36 +0000 | [diff] [blame] | 86 | TmpStr.erase(TmpStr.end()-5, TmpStr.end()); // Remove $stub |
| 87 | |
| 88 | TmpStr += "$lazy_ptr"; |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 89 | LazyPtr = Ctx.GetOrCreateSymbol(TmpStr.str()); |
Chris Lattner | 59b34fe | 2010-01-13 19:05:36 +0000 | [diff] [blame] | 90 | TmpStr.erase(TmpStr.end()-9, TmpStr.end()); // Remove $lazy_ptr |
Chris Lattner | 4813035 | 2010-01-13 06:38:18 +0000 | [diff] [blame] | 91 | |
Chris Lattner | 59b34fe | 2010-01-13 19:05:36 +0000 | [diff] [blame] | 92 | TmpStr += "$stub$tmp"; |
Chris Lattner | 656bb20 | 2010-01-13 19:13:16 +0000 | [diff] [blame] | 93 | AnonSymbol = Ctx.GetOrCreateSymbol(TmpStr.str()); |
Chris Lattner | 9ec8fac | 2009-07-15 02:28:57 +0000 | [diff] [blame] | 94 | } |
| 95 | }; |
| 96 | |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 97 | DenseMap<const MCSymbol*, FnStubInfo> FnStubs; |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 98 | DenseMap<const MCSymbol*, const MCSymbol*> TOC; |
Chris Lattner | dadceed | 2006-09-20 17:07:15 +0000 | [diff] [blame] | 99 | const PPCSubtarget &Subtarget; |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 100 | uint64_t LabelID; |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 101 | public: |
David Greene | 7184781 | 2009-07-14 20:18:05 +0000 | [diff] [blame] | 102 | explicit PPCAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, |
Chris Lattner | af76e59 | 2009-08-22 20:48:53 +0000 | [diff] [blame] | 103 | const MCAsmInfo *T, bool V) |
Daniel Dunbar | 5bcc8bd | 2009-07-01 01:48:54 +0000 | [diff] [blame] | 104 | : AsmPrinter(O, TM, T, V), |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 105 | Subtarget(TM.getSubtarget<PPCSubtarget>()), LabelID(0) {} |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 106 | |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 107 | virtual const char *getPassName() const { |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 108 | return "PowerPC Assembly Printer"; |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 109 | } |
| 110 | |
Nate Begeman | 21e463b | 2005-10-16 05:39:50 +0000 | [diff] [blame] | 111 | PPCTargetMachine &getTM() { |
| 112 | return static_cast<PPCTargetMachine&>(TM); |
Chris Lattner | a384079 | 2004-08-16 23:25:21 +0000 | [diff] [blame] | 113 | } |
| 114 | |
Nate Begeman | adeb43d | 2005-07-20 22:42:00 +0000 | [diff] [blame] | 115 | unsigned enumRegToMachineReg(unsigned enumReg) { |
| 116 | switch (enumReg) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 117 | default: llvm_unreachable("Unhandled register!"); |
Nate Begeman | adeb43d | 2005-07-20 22:42:00 +0000 | [diff] [blame] | 118 | case PPC::CR0: return 0; |
| 119 | case PPC::CR1: return 1; |
| 120 | case PPC::CR2: return 2; |
| 121 | case PPC::CR3: return 3; |
| 122 | case PPC::CR4: return 4; |
| 123 | case PPC::CR5: return 5; |
| 124 | case PPC::CR6: return 6; |
| 125 | case PPC::CR7: return 7; |
| 126 | } |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 127 | llvm_unreachable(0); |
Nate Begeman | adeb43d | 2005-07-20 22:42:00 +0000 | [diff] [blame] | 128 | } |
| 129 | |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 130 | /// printInstruction - This method is automatically generated by tablegen |
| 131 | /// from the instruction set description. This method returns true if the |
| 132 | /// machine instruction was sufficiently described to print it, otherwise it |
| 133 | /// returns false. |
Chris Lattner | 41aefdc | 2009-08-08 01:32:19 +0000 | [diff] [blame] | 134 | void printInstruction(const MachineInstr *MI); |
Chris Lattner | d95148f | 2009-09-13 20:19:22 +0000 | [diff] [blame] | 135 | static const char *getRegisterName(unsigned RegNo); |
Chris Lattner | 05af261 | 2009-09-13 20:08:00 +0000 | [diff] [blame] | 136 | |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 137 | |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 138 | void printMachineInstruction(const MachineInstr *MI); |
Chris Lattner | 9ba13e4 | 2005-11-17 19:25:59 +0000 | [diff] [blame] | 139 | void printOp(const MachineOperand &MO); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 140 | |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 141 | /// stripRegisterPrefix - This method strips the character prefix from a |
| 142 | /// register name so that only the number is left. Used by for linux asm. |
Jim Laskey | 40ee69f | 2006-12-20 21:33:34 +0000 | [diff] [blame] | 143 | const char *stripRegisterPrefix(const char *RegName) { |
| 144 | switch (RegName[0]) { |
| 145 | case 'r': |
| 146 | case 'f': |
| 147 | case 'v': return RegName + 1; |
Jim Laskey | 2aa14aa | 2006-12-20 21:35:00 +0000 | [diff] [blame] | 148 | case 'c': if (RegName[1] == 'r') return RegName + 2; |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 149 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 150 | |
Jim Laskey | 40ee69f | 2006-12-20 21:33:34 +0000 | [diff] [blame] | 151 | return RegName; |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 152 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 153 | |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 154 | /// printRegister - Print register according to target requirements. |
| 155 | /// |
| 156 | void printRegister(const MachineOperand &MO, bool R0AsZero) { |
| 157 | unsigned RegNo = MO.getReg(); |
Dan Gohman | 6f0d024 | 2008-02-10 18:45:23 +0000 | [diff] [blame] | 158 | assert(TargetRegisterInfo::isPhysicalRegister(RegNo) && "Not physreg??"); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 159 | |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 160 | // If we should use 0 for R0. |
| 161 | if (R0AsZero && RegNo == PPC::R0) { |
| 162 | O << "0"; |
| 163 | return; |
| 164 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 165 | |
Chris Lattner | 762ccea | 2009-09-13 20:31:40 +0000 | [diff] [blame] | 166 | const char *RegName = getRegisterName(RegNo); |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 167 | // Linux assembler (Others?) does not take register mnemonics. |
| 168 | // FIXME - What about special registers used in mfspr/mtspr? |
Jim Laskey | 40ee69f | 2006-12-20 21:33:34 +0000 | [diff] [blame] | 169 | if (!Subtarget.isDarwin()) RegName = stripRegisterPrefix(RegName); |
| 170 | O << RegName; |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 171 | } |
Chris Lattner | 7bb424f | 2004-08-14 23:27:29 +0000 | [diff] [blame] | 172 | |
Chris Lattner | 5887327 | 2006-02-01 22:38:46 +0000 | [diff] [blame] | 173 | void printOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 7bb424f | 2004-08-14 23:27:29 +0000 | [diff] [blame] | 174 | const MachineOperand &MO = MI->getOperand(OpNo); |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 175 | if (MO.isReg()) { |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 176 | printRegister(MO, false); |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 177 | } else if (MO.isImm()) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 178 | O << MO.getImm(); |
Chris Lattner | 7bb424f | 2004-08-14 23:27:29 +0000 | [diff] [blame] | 179 | } else { |
| 180 | printOp(MO); |
| 181 | } |
| 182 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 183 | |
Chris Lattner | 5887327 | 2006-02-01 22:38:46 +0000 | [diff] [blame] | 184 | bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 185 | unsigned AsmVariant, const char *ExtraCode); |
Chris Lattner | 2c003e2 | 2006-02-24 20:27:40 +0000 | [diff] [blame] | 186 | bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, |
| 187 | unsigned AsmVariant, const char *ExtraCode); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 188 | |
| 189 | |
Chris Lattner | 9c61dcf | 2006-03-25 06:12:06 +0000 | [diff] [blame] | 190 | void printS5ImmOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 191 | char value = MI->getOperand(OpNo).getImm(); |
Chris Lattner | 9c61dcf | 2006-03-25 06:12:06 +0000 | [diff] [blame] | 192 | value = (value << (32-5)) >> (32-5); |
| 193 | O << (int)value; |
| 194 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 195 | void printU5ImmOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 196 | unsigned char value = MI->getOperand(OpNo).getImm(); |
Chris Lattner | 12585ba | 2004-08-21 19:11:03 +0000 | [diff] [blame] | 197 | assert(value <= 31 && "Invalid u5imm argument!"); |
Nate Begeman | c330612 | 2004-08-21 05:56:39 +0000 | [diff] [blame] | 198 | O << (unsigned int)value; |
| 199 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 200 | void printU6ImmOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 201 | unsigned char value = MI->getOperand(OpNo).getImm(); |
Nate Begeman | 07aada8 | 2004-08-30 02:28:06 +0000 | [diff] [blame] | 202 | assert(value <= 63 && "Invalid u6imm argument!"); |
| 203 | O << (unsigned int)value; |
| 204 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 205 | void printS16ImmOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 206 | O << (short)MI->getOperand(OpNo).getImm(); |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 207 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 208 | void printU16ImmOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 209 | O << (unsigned short)MI->getOperand(OpNo).getImm(); |
Chris Lattner | 97b2a2e | 2004-08-15 05:20:16 +0000 | [diff] [blame] | 210 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 211 | void printS16X4ImmOperand(const MachineInstr *MI, unsigned OpNo) { |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 212 | if (MI->getOperand(OpNo).isImm()) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 213 | O << (short)(MI->getOperand(OpNo).getImm()*4); |
Chris Lattner | 1b0a2d8 | 2006-11-16 21:45:30 +0000 | [diff] [blame] | 214 | } else { |
| 215 | O << "lo16("; |
| 216 | printOp(MI->getOperand(OpNo)); |
| 217 | if (TM.getRelocationModel() == Reloc::PIC_) |
Evan Cheng | 347d39f | 2007-10-14 05:57:21 +0000 | [diff] [blame] | 218 | O << "-\"L" << getFunctionNumber() << "$pb\")"; |
Chris Lattner | 1b0a2d8 | 2006-11-16 21:45:30 +0000 | [diff] [blame] | 219 | else |
| 220 | O << ')'; |
| 221 | } |
Chris Lattner | 841d12d | 2005-10-18 16:51:22 +0000 | [diff] [blame] | 222 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 223 | void printBranchOperand(const MachineInstr *MI, unsigned OpNo) { |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 224 | // Branches can take an immediate operand. This is used by the branch |
| 225 | // selection pass to print $+8, an eight byte displacement from the PC. |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 226 | if (MI->getOperand(OpNo).isImm()) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 227 | O << "$+" << MI->getOperand(OpNo).getImm()*4; |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 228 | } else { |
Chris Lattner | 3e7f86a | 2005-11-17 19:16:08 +0000 | [diff] [blame] | 229 | printOp(MI->getOperand(OpNo)); |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 230 | } |
Nate Begeman | b7a8f2c | 2004-09-02 08:13:00 +0000 | [diff] [blame] | 231 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 232 | void printCallOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9ba13e4 | 2005-11-17 19:25:59 +0000 | [diff] [blame] | 233 | const MachineOperand &MO = MI->getOperand(OpNo); |
Evan Cheng | 4c1aa86 | 2006-02-22 20:19:42 +0000 | [diff] [blame] | 234 | if (TM.getRelocationModel() != Reloc::Static) { |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 235 | if (MO.getType() == MachineOperand::MO_GlobalAddress) { |
| 236 | GlobalValue *GV = MO.getGlobal(); |
Chris Lattner | 2067433 | 2009-07-02 16:08:53 +0000 | [diff] [blame] | 237 | if (GV->isDeclaration() || GV->isWeakForLinker()) { |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 238 | // Dynamically-resolved functions need a stub for the function. |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 239 | FnStubInfo &FnInfo = FnStubs[GetGlobalValueSymbol(GV)]; |
Chris Lattner | 76a3c48 | 2010-01-16 01:45:47 +0000 | [diff] [blame] | 240 | FnInfo.Init(GV, this); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 241 | O << *FnInfo.Stub; |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 242 | return; |
| 243 | } |
| 244 | } |
Chris Lattner | 9542f971 | 2005-11-17 19:40:30 +0000 | [diff] [blame] | 245 | if (MO.getType() == MachineOperand::MO_ExternalSymbol) { |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 246 | FnStubInfo &FnInfo = |
| 247 | FnStubs[GetExternalSymbolSymbol(MO.getSymbolName())]; |
Chris Lattner | 0b4bad5 | 2010-01-13 19:00:57 +0000 | [diff] [blame] | 248 | FnInfo.Init(MO.getSymbolName(), Mang, OutContext); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 249 | O << *FnInfo.Stub; |
Chris Lattner | 9542f971 | 2005-11-17 19:40:30 +0000 | [diff] [blame] | 250 | return; |
Chris Lattner | 9542f971 | 2005-11-17 19:40:30 +0000 | [diff] [blame] | 251 | } |
Chris Lattner | 9ba13e4 | 2005-11-17 19:25:59 +0000 | [diff] [blame] | 252 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 253 | |
Chris Lattner | 9542f971 | 2005-11-17 19:40:30 +0000 | [diff] [blame] | 254 | printOp(MI->getOperand(OpNo)); |
Chris Lattner | 3e7f86a | 2005-11-17 19:16:08 +0000 | [diff] [blame] | 255 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 256 | void printAbsAddrOperand(const MachineInstr *MI, unsigned OpNo) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 257 | O << (int)MI->getOperand(OpNo).getImm()*4; |
Nate Begeman | 422b0ce | 2005-11-16 00:48:01 +0000 | [diff] [blame] | 258 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 259 | void printPICLabel(const MachineInstr *MI, unsigned OpNo) { |
Evan Cheng | 347d39f | 2007-10-14 05:57:21 +0000 | [diff] [blame] | 260 | O << "\"L" << getFunctionNumber() << "$pb\"\n"; |
| 261 | O << "\"L" << getFunctionNumber() << "$pb\":"; |
Nate Begeman | b7a8f2c | 2004-09-02 08:13:00 +0000 | [diff] [blame] | 262 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 263 | void printSymbolHi(const MachineInstr *MI, unsigned OpNo) { |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 264 | if (MI->getOperand(OpNo).isImm()) { |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 265 | printS16ImmOperand(MI, OpNo); |
Nate Begeman | 2497e63 | 2005-07-21 20:44:43 +0000 | [diff] [blame] | 266 | } else { |
Nick Lewycky | f54949d | 2007-03-03 05:29:51 +0000 | [diff] [blame] | 267 | if (Subtarget.isDarwin()) O << "ha16("; |
Nate Begeman | 2497e63 | 2005-07-21 20:44:43 +0000 | [diff] [blame] | 268 | printOp(MI->getOperand(OpNo)); |
Chris Lattner | 35d86fe | 2006-07-26 21:12:04 +0000 | [diff] [blame] | 269 | if (TM.getRelocationModel() == Reloc::PIC_) |
Evan Cheng | 347d39f | 2007-10-14 05:57:21 +0000 | [diff] [blame] | 270 | O << "-\"L" << getFunctionNumber() << "$pb\""; |
Nick Lewycky | f54949d | 2007-03-03 05:29:51 +0000 | [diff] [blame] | 271 | if (Subtarget.isDarwin()) |
Nate Begeman | 2497e63 | 2005-07-21 20:44:43 +0000 | [diff] [blame] | 272 | O << ')'; |
Nick Lewycky | f54949d | 2007-03-03 05:29:51 +0000 | [diff] [blame] | 273 | else |
| 274 | O << "@ha"; |
Nate Begeman | 2497e63 | 2005-07-21 20:44:43 +0000 | [diff] [blame] | 275 | } |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 276 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 277 | void printSymbolLo(const MachineInstr *MI, unsigned OpNo) { |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 278 | if (MI->getOperand(OpNo).isImm()) { |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 279 | printS16ImmOperand(MI, OpNo); |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 280 | } else { |
Nick Lewycky | f54949d | 2007-03-03 05:29:51 +0000 | [diff] [blame] | 281 | if (Subtarget.isDarwin()) O << "lo16("; |
Nate Begeman | d4c8bea | 2004-11-25 07:09:01 +0000 | [diff] [blame] | 282 | printOp(MI->getOperand(OpNo)); |
Chris Lattner | 35d86fe | 2006-07-26 21:12:04 +0000 | [diff] [blame] | 283 | if (TM.getRelocationModel() == Reloc::PIC_) |
Evan Cheng | 347d39f | 2007-10-14 05:57:21 +0000 | [diff] [blame] | 284 | O << "-\"L" << getFunctionNumber() << "$pb\""; |
Nick Lewycky | f54949d | 2007-03-03 05:29:51 +0000 | [diff] [blame] | 285 | if (Subtarget.isDarwin()) |
Nate Begeman | 2497e63 | 2005-07-21 20:44:43 +0000 | [diff] [blame] | 286 | O << ')'; |
Nick Lewycky | f54949d | 2007-03-03 05:29:51 +0000 | [diff] [blame] | 287 | else |
| 288 | O << "@l"; |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 289 | } |
| 290 | } |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 291 | void printcrbitm(const MachineInstr *MI, unsigned OpNo) { |
Nate Begeman | adeb43d | 2005-07-20 22:42:00 +0000 | [diff] [blame] | 292 | unsigned CCReg = MI->getOperand(OpNo).getReg(); |
| 293 | unsigned RegNo = enumRegToMachineReg(CCReg); |
| 294 | O << (0x80 >> RegNo); |
| 295 | } |
Chris Lattner | 2c003e2 | 2006-02-24 20:27:40 +0000 | [diff] [blame] | 296 | // The new addressing mode printers. |
Nate Begeman | 7fd1edd | 2005-12-19 23:25:09 +0000 | [diff] [blame] | 297 | void printMemRegImm(const MachineInstr *MI, unsigned OpNo) { |
| 298 | printSymbolLo(MI, OpNo); |
| 299 | O << '('; |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 300 | if (MI->getOperand(OpNo+1).isReg() && |
Chris Lattner | 13feb58 | 2006-03-21 17:21:13 +0000 | [diff] [blame] | 301 | MI->getOperand(OpNo+1).getReg() == PPC::R0) |
| 302 | O << "0"; |
| 303 | else |
| 304 | printOperand(MI, OpNo+1); |
Nate Begeman | 7fd1edd | 2005-12-19 23:25:09 +0000 | [diff] [blame] | 305 | O << ')'; |
| 306 | } |
Chris Lattner | e5ba580 | 2006-03-22 05:26:03 +0000 | [diff] [blame] | 307 | void printMemRegImmShifted(const MachineInstr *MI, unsigned OpNo) { |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 308 | if (MI->getOperand(OpNo).isImm()) |
Chris Lattner | e5ba580 | 2006-03-22 05:26:03 +0000 | [diff] [blame] | 309 | printS16X4ImmOperand(MI, OpNo); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 310 | else |
Chris Lattner | e5ba580 | 2006-03-22 05:26:03 +0000 | [diff] [blame] | 311 | printSymbolLo(MI, OpNo); |
| 312 | O << '('; |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 313 | if (MI->getOperand(OpNo+1).isReg() && |
Chris Lattner | e5ba580 | 2006-03-22 05:26:03 +0000 | [diff] [blame] | 314 | MI->getOperand(OpNo+1).getReg() == PPC::R0) |
| 315 | O << "0"; |
| 316 | else |
| 317 | printOperand(MI, OpNo+1); |
| 318 | O << ')'; |
| 319 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 320 | |
Nate Begeman | 7fd1edd | 2005-12-19 23:25:09 +0000 | [diff] [blame] | 321 | void printMemRegReg(const MachineInstr *MI, unsigned OpNo) { |
Nate Begeman | 88276b8 | 2005-12-19 23:40:42 +0000 | [diff] [blame] | 322 | // When used as the base register, r0 reads constant zero rather than |
| 323 | // the value contained in the register. For this reason, the darwin |
| 324 | // assembler requires that we print r0 as 0 (no r) when used as the base. |
| 325 | const MachineOperand &MO = MI->getOperand(OpNo); |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 326 | printRegister(MO, true); |
Nate Begeman | 7fd1edd | 2005-12-19 23:25:09 +0000 | [diff] [blame] | 327 | O << ", "; |
| 328 | printOperand(MI, OpNo+1); |
| 329 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 330 | |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 331 | void printTOCEntryLabel(const MachineInstr *MI, unsigned OpNo) { |
| 332 | const MachineOperand &MO = MI->getOperand(OpNo); |
| 333 | |
| 334 | assert(MO.getType() == MachineOperand::MO_GlobalAddress); |
| 335 | |
Chris Lattner | 75abc68 | 2010-01-16 02:09:06 +0000 | [diff] [blame] | 336 | const MCSymbol *Sym = GetGlobalValueSymbol(MO.getGlobal()); |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 337 | |
| 338 | // Map symbol -> label of TOC entry. |
Chris Lattner | 75abc68 | 2010-01-16 02:09:06 +0000 | [diff] [blame] | 339 | const MCSymbol *&TOCEntry = TOC[Sym]; |
| 340 | if (TOCEntry == 0) |
| 341 | TOCEntry = OutContext. |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 342 | GetOrCreateSymbol(StringRef(MAI->getPrivateGlobalPrefix()) + "C" + |
| 343 | Twine(LabelID++)); |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 344 | |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 345 | O << *TOCEntry << "@toc"; |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 346 | } |
| 347 | |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 348 | void printPredicateOperand(const MachineInstr *MI, unsigned OpNo, |
Chris Lattner | af53a87 | 2006-11-04 05:27:39 +0000 | [diff] [blame] | 349 | const char *Modifier); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 350 | |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 351 | virtual bool runOnMachineFunction(MachineFunction &F) = 0; |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 352 | }; |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 353 | |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 354 | /// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux |
Nick Lewycky | 6726b6d | 2009-10-25 06:33:48 +0000 | [diff] [blame] | 355 | class PPCLinuxAsmPrinter : public PPCAsmPrinter { |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 356 | public: |
Daniel Dunbar | 51b198a | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 357 | explicit PPCLinuxAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, |
Chris Lattner | af76e59 | 2009-08-22 20:48:53 +0000 | [diff] [blame] | 358 | const MCAsmInfo *T, bool V) |
Daniel Dunbar | 5bcc8bd | 2009-07-01 01:48:54 +0000 | [diff] [blame] | 359 | : PPCAsmPrinter(O, TM, T, V){} |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 360 | |
| 361 | virtual const char *getPassName() const { |
| 362 | return "Linux PPC Assembly Printer"; |
| 363 | } |
| 364 | |
| 365 | bool runOnMachineFunction(MachineFunction &F); |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 366 | bool doFinalization(Module &M); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 367 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 368 | void getAnalysisUsage(AnalysisUsage &AU) const { |
| 369 | AU.setPreservesAll(); |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 370 | AU.addRequired<MachineModuleInfo>(); |
Devang Patel | eb3fc28 | 2009-01-08 23:40:34 +0000 | [diff] [blame] | 371 | AU.addRequired<DwarfWriter>(); |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 372 | PPCAsmPrinter::getAnalysisUsage(AU); |
| 373 | } |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 374 | }; |
| 375 | |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 376 | /// PPCDarwinAsmPrinter - PowerPC assembly printer, customized for Darwin/Mac |
| 377 | /// OS X |
Nick Lewycky | 6726b6d | 2009-10-25 06:33:48 +0000 | [diff] [blame] | 378 | class PPCDarwinAsmPrinter : public PPCAsmPrinter { |
David Greene | 7184781 | 2009-07-14 20:18:05 +0000 | [diff] [blame] | 379 | formatted_raw_ostream &OS; |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 380 | public: |
Daniel Dunbar | 51b198a | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 381 | explicit PPCDarwinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM, |
Chris Lattner | af76e59 | 2009-08-22 20:48:53 +0000 | [diff] [blame] | 382 | const MCAsmInfo *T, bool V) |
Daniel Dunbar | 5bcc8bd | 2009-07-01 01:48:54 +0000 | [diff] [blame] | 383 | : PPCAsmPrinter(O, TM, T, V), OS(O) {} |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 384 | |
| 385 | virtual const char *getPassName() const { |
| 386 | return "Darwin PPC Assembly Printer"; |
| 387 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 388 | |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 389 | bool runOnMachineFunction(MachineFunction &F); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 390 | bool doFinalization(Module &M); |
Bob Wilson | 812209a | 2009-09-30 22:06:26 +0000 | [diff] [blame] | 391 | void EmitStartOfAsmFile(Module &M); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 392 | |
Jim Laskey | b2efb85 | 2006-01-04 22:28:25 +0000 | [diff] [blame] | 393 | void getAnalysisUsage(AnalysisUsage &AU) const { |
Jim Laskey | abf6d17 | 2006-01-05 01:25:28 +0000 | [diff] [blame] | 394 | AU.setPreservesAll(); |
Jim Laskey | 44c3b9f | 2007-01-26 21:22:28 +0000 | [diff] [blame] | 395 | AU.addRequired<MachineModuleInfo>(); |
Devang Patel | eb3fc28 | 2009-01-08 23:40:34 +0000 | [diff] [blame] | 396 | AU.addRequired<DwarfWriter>(); |
Jim Laskey | abf6d17 | 2006-01-05 01:25:28 +0000 | [diff] [blame] | 397 | PPCAsmPrinter::getAnalysisUsage(AU); |
Jim Laskey | b2efb85 | 2006-01-04 22:28:25 +0000 | [diff] [blame] | 398 | } |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 399 | }; |
| 400 | } // end of anonymous namespace |
| 401 | |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 402 | // Include the auto-generated portion of the assembly writer |
Chris Lattner | 4c7b43b | 2005-10-14 23:37:35 +0000 | [diff] [blame] | 403 | #include "PPCGenAsmWriter.inc" |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 404 | |
Chris Lattner | 9ba13e4 | 2005-11-17 19:25:59 +0000 | [diff] [blame] | 405 | void PPCAsmPrinter::printOp(const MachineOperand &MO) { |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 406 | switch (MO.getType()) { |
Chris Lattner | 63b3d71 | 2006-05-04 17:21:20 +0000 | [diff] [blame] | 407 | case MachineOperand::MO_Immediate: |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 408 | llvm_unreachable("printOp() does not handle immediate values"); |
Misha Brukman | 97a296f | 2004-07-21 20:11:11 +0000 | [diff] [blame] | 409 | |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 410 | case MachineOperand::MO_MachineBasicBlock: |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 411 | O << *GetMBBSymbol(MO.getMBB()->getNumber()); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 412 | return; |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 413 | case MachineOperand::MO_JumpTableIndex: |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 414 | O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 415 | << '_' << MO.getIndex(); |
Nate Begeman | 37efe67 | 2006-04-22 18:53:45 +0000 | [diff] [blame] | 416 | // FIXME: PIC relocation model |
| 417 | return; |
Misha Brukman | 05fcd0c | 2004-07-08 17:58:04 +0000 | [diff] [blame] | 418 | case MachineOperand::MO_ConstantPoolIndex: |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 419 | O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() |
Chris Lattner | 8aa797a | 2007-12-30 23:10:15 +0000 | [diff] [blame] | 420 | << '_' << MO.getIndex(); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 421 | return; |
Bob Wilson | 3d90dbe | 2009-11-04 21:31:18 +0000 | [diff] [blame] | 422 | case MachineOperand::MO_BlockAddress: |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 423 | O << *GetBlockAddressSymbol(MO.getBlockAddress()); |
Bob Wilson | 3d90dbe | 2009-11-04 21:31:18 +0000 | [diff] [blame] | 424 | return; |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 425 | case MachineOperand::MO_ExternalSymbol: { |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 426 | // Computing the address of an external symbol, not calling it. |
Chris Lattner | 75abc68 | 2010-01-16 02:09:06 +0000 | [diff] [blame] | 427 | if (TM.getRelocationModel() == Reloc::Static) { |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 428 | O << *GetExternalSymbolSymbol(MO.getSymbolName()); |
Chris Lattner | 75abc68 | 2010-01-16 02:09:06 +0000 | [diff] [blame] | 429 | return; |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 430 | } |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 431 | |
Chris Lattner | 75abc68 | 2010-01-16 02:09:06 +0000 | [diff] [blame] | 432 | const MCSymbol *NLPSym = |
| 433 | OutContext.GetOrCreateSymbol(StringRef(MAI->getGlobalPrefix())+ |
| 434 | MO.getSymbolName()+"$non_lazy_ptr"); |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 435 | const MCSymbol *&StubSym = |
| 436 | MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(NLPSym); |
| 437 | if (StubSym == 0) |
| 438 | StubSym = GetExternalSymbolSymbol(MO.getSymbolName()); |
| 439 | |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 440 | O << *NLPSym; |
Misha Brukman | 05fcd0c | 2004-07-08 17:58:04 +0000 | [diff] [blame] | 441 | return; |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 442 | } |
Nate Begeman | b73a711 | 2004-08-13 09:32:01 +0000 | [diff] [blame] | 443 | case MachineOperand::MO_GlobalAddress: { |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 444 | // Computing the address of a global symbol, not calling it. |
Nate Begeman | b73a711 | 2004-08-13 09:32:01 +0000 | [diff] [blame] | 445 | GlobalValue *GV = MO.getGlobal(); |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 446 | MCSymbol *SymToPrint; |
Misha Brukman | e2eceb5 | 2004-07-23 16:08:20 +0000 | [diff] [blame] | 447 | |
Nate Begeman | fcf4a42 | 2004-10-17 23:01:34 +0000 | [diff] [blame] | 448 | // External or weakly linked global variables need non-lazily-resolved stubs |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 449 | if (TM.getRelocationModel() != Reloc::Static && |
| 450 | (GV->isDeclaration() || GV->isWeakForLinker())) { |
| 451 | if (!GV->hasHiddenVisibility()) { |
Chris Lattner | 7a2ba94 | 2010-01-16 18:37:32 +0000 | [diff] [blame] | 452 | SymToPrint = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 453 | const MCSymbol *&StubSym = |
| 454 | MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(SymToPrint); |
| 455 | if (StubSym == 0) |
| 456 | StubSym = GetGlobalValueSymbol(GV); |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 457 | } else if (GV->isDeclaration() || GV->hasCommonLinkage() || |
| 458 | GV->hasAvailableExternallyLinkage()) { |
Chris Lattner | 7a2ba94 | 2010-01-16 18:37:32 +0000 | [diff] [blame] | 459 | SymToPrint = GetSymbolWithGlobalValueBase(GV, "$non_lazy_ptr"); |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 460 | |
| 461 | const MCSymbol *&StubSym = |
| 462 | MMI->getObjFileInfo<MachineModuleInfoMachO>(). |
| 463 | getHiddenGVStubEntry(SymToPrint); |
| 464 | if (StubSym == 0) |
| 465 | StubSym = GetGlobalValueSymbol(GV); |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 466 | } else { |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 467 | SymToPrint = GetGlobalValueSymbol(GV); |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 468 | } |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 469 | } else { |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 470 | SymToPrint = GetGlobalValueSymbol(GV); |
Nate Begeman | b73a711 | 2004-08-13 09:32:01 +0000 | [diff] [blame] | 471 | } |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 472 | |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 473 | O << *SymToPrint; |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 474 | |
Anton Korobeynikov | 7751ad9 | 2008-11-22 16:15:34 +0000 | [diff] [blame] | 475 | printOffset(MO.getOffset()); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 476 | return; |
Nate Begeman | b73a711 | 2004-08-13 09:32:01 +0000 | [diff] [blame] | 477 | } |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 478 | |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 479 | default: |
Misha Brukman | 05fcd0c | 2004-07-08 17:58:04 +0000 | [diff] [blame] | 480 | O << "<unknown operand type: " << MO.getType() << ">"; |
Misha Brukman | 22e1207 | 2004-06-25 15:11:34 +0000 | [diff] [blame] | 481 | return; |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 482 | } |
| 483 | } |
| 484 | |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 485 | /// PrintAsmOperand - Print out an operand for an inline asm expression. |
| 486 | /// |
| 487 | bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 488 | unsigned AsmVariant, |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 489 | const char *ExtraCode) { |
| 490 | // Does this asm operand have a single letter operand modifier? |
| 491 | if (ExtraCode && ExtraCode[0]) { |
| 492 | if (ExtraCode[1] != 0) return true; // Unknown modifier. |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 493 | |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 494 | switch (ExtraCode[0]) { |
| 495 | default: return true; // Unknown modifier. |
Chris Lattner | 78192b6 | 2007-01-25 02:52:50 +0000 | [diff] [blame] | 496 | case 'c': // Don't print "$" before a global var name or constant. |
| 497 | // PPC never has a prefix. |
| 498 | printOperand(MI, OpNo); |
| 499 | return false; |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 500 | case 'L': // Write second word of DImode reference. |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 501 | // Verify that this operand has two consecutive registers. |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 502 | if (!MI->getOperand(OpNo).isReg() || |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 503 | OpNo+1 == MI->getNumOperands() || |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 504 | !MI->getOperand(OpNo+1).isReg()) |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 505 | return true; |
| 506 | ++OpNo; // Return the high-part. |
| 507 | break; |
Chris Lattner | 6c2d260 | 2007-04-24 22:51:03 +0000 | [diff] [blame] | 508 | case 'I': |
| 509 | // Write 'i' if an integer constant, otherwise nothing. Used to print |
| 510 | // addi vs add, etc. |
Dan Gohman | d735b80 | 2008-10-03 15:45:36 +0000 | [diff] [blame] | 511 | if (MI->getOperand(OpNo).isImm()) |
Chris Lattner | 6c2d260 | 2007-04-24 22:51:03 +0000 | [diff] [blame] | 512 | O << "i"; |
| 513 | return false; |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 514 | } |
| 515 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 516 | |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 517 | printOperand(MI, OpNo); |
| 518 | return false; |
| 519 | } |
| 520 | |
Dale Johannesen | 5cfd4dd | 2009-08-18 00:18:39 +0000 | [diff] [blame] | 521 | // At the moment, all inline asm memory operands are a single register. |
| 522 | // In any case, the output of this routine should always be just one |
| 523 | // assembler operand. |
| 524 | |
Chris Lattner | 2c003e2 | 2006-02-24 20:27:40 +0000 | [diff] [blame] | 525 | bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 526 | unsigned AsmVariant, |
Chris Lattner | 2c003e2 | 2006-02-24 20:27:40 +0000 | [diff] [blame] | 527 | const char *ExtraCode) { |
| 528 | if (ExtraCode && ExtraCode[0]) |
| 529 | return true; // Unknown modifier. |
Dale Johannesen | 5cfd4dd | 2009-08-18 00:18:39 +0000 | [diff] [blame] | 530 | assert (MI->getOperand(OpNo).isReg()); |
Dale Johannesen | 4e68f88 | 2009-08-26 18:10:32 +0000 | [diff] [blame] | 531 | O << "0("; |
Dale Johannesen | 5cfd4dd | 2009-08-18 00:18:39 +0000 | [diff] [blame] | 532 | printOperand(MI, OpNo); |
Dale Johannesen | 4e68f88 | 2009-08-26 18:10:32 +0000 | [diff] [blame] | 533 | O << ")"; |
Chris Lattner | 2c003e2 | 2006-02-24 20:27:40 +0000 | [diff] [blame] | 534 | return false; |
| 535 | } |
Chris Lattner | e3f0157 | 2006-02-23 19:31:10 +0000 | [diff] [blame] | 536 | |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 537 | void PPCAsmPrinter::printPredicateOperand(const MachineInstr *MI, unsigned OpNo, |
Chris Lattner | af53a87 | 2006-11-04 05:27:39 +0000 | [diff] [blame] | 538 | const char *Modifier) { |
| 539 | assert(Modifier && "Must specify 'cc' or 'reg' as predicate op modifier!"); |
| 540 | unsigned Code = MI->getOperand(OpNo).getImm(); |
| 541 | if (!strcmp(Modifier, "cc")) { |
| 542 | switch ((PPC::Predicate)Code) { |
| 543 | case PPC::PRED_ALWAYS: return; // Don't print anything for always. |
| 544 | case PPC::PRED_LT: O << "lt"; return; |
| 545 | case PPC::PRED_LE: O << "le"; return; |
| 546 | case PPC::PRED_EQ: O << "eq"; return; |
| 547 | case PPC::PRED_GE: O << "ge"; return; |
| 548 | case PPC::PRED_GT: O << "gt"; return; |
| 549 | case PPC::PRED_NE: O << "ne"; return; |
| 550 | case PPC::PRED_UN: O << "un"; return; |
| 551 | case PPC::PRED_NU: O << "nu"; return; |
| 552 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 553 | |
Chris Lattner | af53a87 | 2006-11-04 05:27:39 +0000 | [diff] [blame] | 554 | } else { |
| 555 | assert(!strcmp(Modifier, "reg") && |
| 556 | "Need to specify 'cc' or 'reg' as predicate op modifier!"); |
| 557 | // Don't print the register for 'always'. |
| 558 | if (Code == PPC::PRED_ALWAYS) return; |
| 559 | printOperand(MI, OpNo+1); |
| 560 | } |
| 561 | } |
| 562 | |
| 563 | |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 564 | /// printMachineInstruction -- Print out a single PowerPC MI in Darwin syntax to |
| 565 | /// the current output stream. |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 566 | /// |
Chris Lattner | 4c7b43b | 2005-10-14 23:37:35 +0000 | [diff] [blame] | 567 | void PPCAsmPrinter::printMachineInstruction(const MachineInstr *MI) { |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 568 | ++EmittedInsts; |
Chris Lattner | 634cca3 | 2009-09-09 20:34:59 +0000 | [diff] [blame] | 569 | |
Devang Patel | af0e272 | 2009-10-06 02:19:11 +0000 | [diff] [blame] | 570 | processDebugLoc(MI, true); |
Chris Lattner | 617742b | 2005-10-14 22:44:13 +0000 | [diff] [blame] | 571 | |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 572 | // Check for slwi/srwi mnemonics. |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 573 | bool useSubstituteMnemonic = false; |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 574 | if (MI->getOpcode() == PPC::RLWINM) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 575 | unsigned char SH = MI->getOperand(2).getImm(); |
| 576 | unsigned char MB = MI->getOperand(3).getImm(); |
| 577 | unsigned char ME = MI->getOperand(4).getImm(); |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 578 | if (SH <= 31 && MB == 0 && ME == (31-SH)) { |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 579 | O << "\tslwi "; useSubstituteMnemonic = true; |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 580 | } |
| 581 | if (SH <= 31 && MB == (32-SH) && ME == 31) { |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 582 | O << "\tsrwi "; useSubstituteMnemonic = true; |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 583 | SH = 32-SH; |
| 584 | } |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 585 | if (useSubstituteMnemonic) { |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 586 | printOperand(MI, 0); |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 587 | O << ", "; |
Nate Begeman | 391c5d2 | 2005-11-30 18:54:35 +0000 | [diff] [blame] | 588 | printOperand(MI, 1); |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 589 | O << ", " << (unsigned int)SH; |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 590 | } |
Chris Lattner | b410dc9 | 2006-06-20 23:18:58 +0000 | [diff] [blame] | 591 | } else if (MI->getOpcode() == PPC::OR || MI->getOpcode() == PPC::OR8) { |
Chris Lattner | 4d73a5a | 2006-02-08 06:56:40 +0000 | [diff] [blame] | 592 | if (MI->getOperand(1).getReg() == MI->getOperand(2).getReg()) { |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 593 | useSubstituteMnemonic = true; |
Nate Begeman | 5a804e3 | 2008-02-05 08:49:09 +0000 | [diff] [blame] | 594 | O << "\tmr "; |
Chris Lattner | 4d73a5a | 2006-02-08 06:56:40 +0000 | [diff] [blame] | 595 | printOperand(MI, 0); |
| 596 | O << ", "; |
| 597 | printOperand(MI, 1); |
Chris Lattner | 4d73a5a | 2006-02-08 06:56:40 +0000 | [diff] [blame] | 598 | } |
Chris Lattner | 566c1b1 | 2006-11-18 01:23:56 +0000 | [diff] [blame] | 599 | } else if (MI->getOpcode() == PPC::RLDICR) { |
Chris Lattner | 9a1ceae | 2007-12-30 20:49:49 +0000 | [diff] [blame] | 600 | unsigned char SH = MI->getOperand(2).getImm(); |
| 601 | unsigned char ME = MI->getOperand(3).getImm(); |
Chris Lattner | 566c1b1 | 2006-11-18 01:23:56 +0000 | [diff] [blame] | 602 | // rldicr RA, RS, SH, 63-SH == sldi RA, RS, SH |
| 603 | if (63-SH == ME) { |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 604 | useSubstituteMnemonic = true; |
Nate Begeman | 5a804e3 | 2008-02-05 08:49:09 +0000 | [diff] [blame] | 605 | O << "\tsldi "; |
Chris Lattner | 566c1b1 | 2006-11-18 01:23:56 +0000 | [diff] [blame] | 606 | printOperand(MI, 0); |
| 607 | O << ", "; |
| 608 | printOperand(MI, 1); |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 609 | O << ", " << (unsigned int)SH; |
Chris Lattner | 566c1b1 | 2006-11-18 01:23:56 +0000 | [diff] [blame] | 610 | } |
Nate Begeman | ad5f65c | 2005-04-05 18:19:50 +0000 | [diff] [blame] | 611 | } |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 612 | |
Dale Johannesen | e89c510 | 2010-01-06 02:20:18 +0000 | [diff] [blame] | 613 | if (!useSubstituteMnemonic) |
| 614 | printInstruction(MI); |
| 615 | |
David Greene | 1924aab | 2009-11-13 21:34:57 +0000 | [diff] [blame] | 616 | if (VerboseAsm) |
Chris Lattner | c5ea263 | 2009-09-09 23:14:36 +0000 | [diff] [blame] | 617 | EmitComments(*MI); |
| 618 | O << '\n'; |
Devang Patel | af0e272 | 2009-10-06 02:19:11 +0000 | [diff] [blame] | 619 | |
| 620 | processDebugLoc(MI, false); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 621 | } |
| 622 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 623 | /// runOnMachineFunction - This uses the printMachineInstruction() |
| 624 | /// method to print assembly for each instruction. |
| 625 | /// |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 626 | bool PPCLinuxAsmPrinter::runOnMachineFunction(MachineFunction &MF) { |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 627 | this->MF = &MF; |
Chris Lattner | 9b7ce7d | 2006-10-05 02:42:20 +0000 | [diff] [blame] | 628 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 629 | SetupMachineFunction(MF); |
| 630 | O << "\n\n"; |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 631 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 632 | // Print out constants referenced by the function |
| 633 | EmitConstantPool(MF.getConstantPool()); |
| 634 | |
| 635 | // Print out labels for the function. |
| 636 | const Function *F = MF.getFunction(); |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 637 | OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 638 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 639 | switch (F->getLinkage()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 640 | default: llvm_unreachable("Unknown linkage type!"); |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 641 | case Function::PrivateLinkage: |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 642 | case Function::InternalLinkage: // Symbols default to internal. |
| 643 | break; |
| 644 | case Function::ExternalLinkage: |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 645 | O << "\t.global\t" << *CurrentFnSym << '\n' << "\t.type\t"; |
| 646 | O << *CurrentFnSym << ", @function\n"; |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 647 | break; |
Dale Johannesen | a60e51f | 2009-08-24 01:03:42 +0000 | [diff] [blame] | 648 | case Function::LinkerPrivateLinkage: |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 649 | case Function::WeakAnyLinkage: |
| 650 | case Function::WeakODRLinkage: |
| 651 | case Function::LinkOnceAnyLinkage: |
| 652 | case Function::LinkOnceODRLinkage: |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 653 | O << "\t.global\t" << *CurrentFnSym << '\n'; |
| 654 | O << "\t.weak\t" << *CurrentFnSym << '\n'; |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 655 | break; |
| 656 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 657 | |
Chris Lattner | 1216441 | 2010-01-16 00:21:18 +0000 | [diff] [blame] | 658 | printVisibility(CurrentFnSym, F->getVisibility()); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 659 | |
Bill Wendling | 20c568f | 2009-06-30 22:38:32 +0000 | [diff] [blame] | 660 | EmitAlignment(MF.getAlignment(), F); |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 661 | |
| 662 | if (Subtarget.isPPC64()) { |
| 663 | // Emit an official procedure descriptor. |
Chris Lattner | 1216441 | 2010-01-16 00:21:18 +0000 | [diff] [blame] | 664 | // FIXME 64-bit SVR4: Use MCSection here! |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 665 | O << "\t.section\t\".opd\",\"aw\"\n"; |
| 666 | O << "\t.align 3\n"; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 667 | O << *CurrentFnSym << ":\n"; |
| 668 | O << "\t.quad .L." << *CurrentFnSym << ",.TOC.@tocbase\n"; |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 669 | O << "\t.previous\n"; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 670 | O << ".L." << *CurrentFnSym << ":\n"; |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 671 | } else { |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 672 | O << *CurrentFnSym << ":\n"; |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 673 | } |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 674 | |
| 675 | // Emit pre-function debug information. |
Devang Patel | eb3fc28 | 2009-01-08 23:40:34 +0000 | [diff] [blame] | 676 | DW->BeginFunction(&MF); |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 677 | |
| 678 | // Print out code for the function. |
| 679 | for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); |
| 680 | I != E; ++I) { |
| 681 | // Print a label for the basic block. |
| 682 | if (I != MF.begin()) { |
Chris Lattner | 70a54c0 | 2009-09-13 18:25:37 +0000 | [diff] [blame] | 683 | EmitBasicBlockStart(I); |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 684 | } |
| 685 | for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); |
| 686 | II != E; ++II) { |
| 687 | // Print the assembly for the instruction. |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 688 | printMachineInstruction(II); |
| 689 | } |
| 690 | } |
| 691 | |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 692 | O << "\t.size\t" << *CurrentFnSym << ",.-" << *CurrentFnSym << '\n'; |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 693 | |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 694 | OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); |
Dale Johannesen | f94a327 | 2008-12-03 19:33:10 +0000 | [diff] [blame] | 695 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 696 | // Emit post-function debug information. |
Devang Patel | eb3fc28 | 2009-01-08 23:40:34 +0000 | [diff] [blame] | 697 | DW->EndFunction(&MF); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 698 | |
Bill Wendling | b1ec31d | 2009-11-09 21:20:14 +0000 | [diff] [blame] | 699 | // Print out jump tables referenced by the function. |
| 700 | EmitJumpTableInfo(MF.getJumpTableInfo(), MF); |
| 701 | |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 702 | // We didn't modify anything. |
| 703 | return false; |
| 704 | } |
| 705 | |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 706 | bool PPCLinuxAsmPrinter::doFinalization(Module &M) { |
| 707 | const TargetData *TD = TM.getTargetData(); |
| 708 | |
| 709 | bool isPPC64 = TD->getPointerSizeInBits() == 64; |
| 710 | |
| 711 | if (isPPC64 && !TOC.empty()) { |
| 712 | // FIXME 64-bit SVR4: Use MCSection here? |
| 713 | O << "\t.section\t\".toc\",\"aw\"\n"; |
| 714 | |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 715 | // FIXME: This is nondeterminstic! |
Chris Lattner | 75abc68 | 2010-01-16 02:09:06 +0000 | [diff] [blame] | 716 | for (DenseMap<const MCSymbol*, const MCSymbol*>::iterator I = TOC.begin(), |
| 717 | E = TOC.end(); I != E; ++I) { |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 718 | O << *I->second << ":\n"; |
| 719 | O << "\t.tc " << *I->first << "[TC]," << *I->first << '\n'; |
Tilmann Scheller | 6b16eff | 2009-08-15 11:54:46 +0000 | [diff] [blame] | 720 | } |
| 721 | } |
| 722 | |
| 723 | return AsmPrinter::doFinalization(M); |
| 724 | } |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 725 | |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 726 | /// runOnMachineFunction - This uses the printMachineInstruction() |
| 727 | /// method to print assembly for each instruction. |
| 728 | /// |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 729 | bool PPCDarwinAsmPrinter::runOnMachineFunction(MachineFunction &MF) { |
Bill Wendling | 57f0db8 | 2009-02-24 08:30:20 +0000 | [diff] [blame] | 730 | this->MF = &MF; |
| 731 | |
Chris Lattner | 8b8b951 | 2005-11-21 07:51:23 +0000 | [diff] [blame] | 732 | SetupMachineFunction(MF); |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 733 | O << "\n\n"; |
Dale Johannesen | 1d4ce2a | 2007-11-20 23:24:42 +0000 | [diff] [blame] | 734 | |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 735 | // Print out constants referenced by the function |
Chris Lattner | c569e61 | 2005-11-21 08:26:15 +0000 | [diff] [blame] | 736 | EmitConstantPool(MF.getConstantPool()); |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 737 | |
| 738 | // Print out labels for the function. |
Chris Lattner | ac7fd7f | 2005-11-14 18:52:46 +0000 | [diff] [blame] | 739 | const Function *F = MF.getFunction(); |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 740 | OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 741 | |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 742 | switch (F->getLinkage()) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 743 | default: llvm_unreachable("Unknown linkage type!"); |
Evan Cheng | 1902a12 | 2009-01-25 06:32:01 +0000 | [diff] [blame] | 744 | case Function::PrivateLinkage: |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 745 | case Function::InternalLinkage: // Symbols default to internal. |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 746 | break; |
| 747 | case Function::ExternalLinkage: |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 748 | O << "\t.globl\t" << *CurrentFnSym << '\n'; |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 749 | break; |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 750 | case Function::WeakAnyLinkage: |
| 751 | case Function::WeakODRLinkage: |
| 752 | case Function::LinkOnceAnyLinkage: |
| 753 | case Function::LinkOnceODRLinkage: |
Dale Johannesen | a60e51f | 2009-08-24 01:03:42 +0000 | [diff] [blame] | 754 | case Function::LinkerPrivateLinkage: |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 755 | O << "\t.globl\t" << *CurrentFnSym << '\n'; |
| 756 | O << "\t.weak_definition\t" << *CurrentFnSym << '\n'; |
Chris Lattner | a637c32 | 2005-12-16 00:22:14 +0000 | [diff] [blame] | 757 | break; |
| 758 | } |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 759 | |
Chris Lattner | 1216441 | 2010-01-16 00:21:18 +0000 | [diff] [blame] | 760 | printVisibility(CurrentFnSym, F->getVisibility()); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 761 | |
Bill Wendling | 20c568f | 2009-06-30 22:38:32 +0000 | [diff] [blame] | 762 | EmitAlignment(MF.getAlignment(), F); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 763 | O << *CurrentFnSym << ":\n"; |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 764 | |
Jim Laskey | 6b92b8e | 2006-04-07 20:44:42 +0000 | [diff] [blame] | 765 | // Emit pre-function debug information. |
Devang Patel | eb3fc28 | 2009-01-08 23:40:34 +0000 | [diff] [blame] | 766 | DW->BeginFunction(&MF); |
Jim Laskey | 6b92b8e | 2006-04-07 20:44:42 +0000 | [diff] [blame] | 767 | |
Bill Wendling | 381802f | 2008-01-26 06:51:24 +0000 | [diff] [blame] | 768 | // If the function is empty, then we need to emit *something*. Otherwise, the |
| 769 | // function's label might be associated with something that it wasn't meant to |
| 770 | // be associated with. We emit a noop in this situation. |
| 771 | MachineFunction::iterator I = MF.begin(); |
| 772 | |
Bill Wendling | 824a721 | 2008-01-26 09:03:52 +0000 | [diff] [blame] | 773 | if (++I == MF.end() && MF.front().empty()) |
| 774 | O << "\tnop\n"; |
Bill Wendling | 381802f | 2008-01-26 06:51:24 +0000 | [diff] [blame] | 775 | |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 776 | // Print out code for the function. |
| 777 | for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); |
| 778 | I != E; ++I) { |
| 779 | // Print a label for the basic block. |
Chris Lattner | 1db1adb | 2005-08-21 19:09:33 +0000 | [diff] [blame] | 780 | if (I != MF.begin()) { |
Chris Lattner | 70a54c0 | 2009-09-13 18:25:37 +0000 | [diff] [blame] | 781 | EmitBasicBlockStart(I); |
Chris Lattner | 1db1adb | 2005-08-21 19:09:33 +0000 | [diff] [blame] | 782 | } |
Bill Wendling | 381802f | 2008-01-26 06:51:24 +0000 | [diff] [blame] | 783 | for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); |
| 784 | II != IE; ++II) { |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 785 | // Print the assembly for the instruction. |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 786 | printMachineInstruction(II); |
| 787 | } |
| 788 | } |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 789 | |
Jim Laskey | a7cea6f | 2006-01-04 13:52:30 +0000 | [diff] [blame] | 790 | // Emit post-function debug information. |
Devang Patel | eb3fc28 | 2009-01-08 23:40:34 +0000 | [diff] [blame] | 791 | DW->EndFunction(&MF); |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 792 | |
Bill Wendling | 2718e43 | 2009-11-09 21:45:26 +0000 | [diff] [blame] | 793 | // Print out jump tables referenced by the function. |
| 794 | EmitJumpTableInfo(MF.getJumpTableInfo(), MF); |
| 795 | |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 796 | // We didn't modify anything. |
| 797 | return false; |
| 798 | } |
| 799 | |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 800 | |
Bob Wilson | 812209a | 2009-09-30 22:06:26 +0000 | [diff] [blame] | 801 | void PPCDarwinAsmPrinter::EmitStartOfAsmFile(Module &M) { |
Dan Gohman | cfbb2f0 | 2008-03-25 21:45:14 +0000 | [diff] [blame] | 802 | static const char *const CPUDirectives[] = { |
Dale Johannesen | db01c8b | 2008-02-14 23:35:16 +0000 | [diff] [blame] | 803 | "", |
Jim Laskey | c35010d | 2006-12-12 20:57:08 +0000 | [diff] [blame] | 804 | "ppc", |
| 805 | "ppc601", |
| 806 | "ppc602", |
| 807 | "ppc603", |
| 808 | "ppc7400", |
| 809 | "ppc750", |
| 810 | "ppc970", |
| 811 | "ppc64" |
| 812 | }; |
| 813 | |
| 814 | unsigned Directive = Subtarget.getDarwinDirective(); |
| 815 | if (Subtarget.isGigaProcessor() && Directive < PPC::DIR_970) |
| 816 | Directive = PPC::DIR_970; |
| 817 | if (Subtarget.hasAltivec() && Directive < PPC::DIR_7400) |
| 818 | Directive = PPC::DIR_7400; |
| 819 | if (Subtarget.isPPC64() && Directive < PPC::DIR_970) |
| 820 | Directive = PPC::DIR_64; |
| 821 | assert(Directive <= PPC::DIR_64 && "Directive out of range."); |
Anton Korobeynikov | 382f002 | 2008-08-08 18:24:10 +0000 | [diff] [blame] | 822 | O << "\t.machine " << CPUDirectives[Directive] << '\n'; |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 823 | |
Jim Laskey | 2ada085 | 2006-11-28 18:21:52 +0000 | [diff] [blame] | 824 | // Prime text sections so they are adjacent. This reduces the likelihood a |
| 825 | // large data or debug section causes a branch to exceed 16M limit. |
Chris Lattner | 2dfddee | 2009-08-03 22:52:21 +0000 | [diff] [blame] | 826 | TargetLoweringObjectFileMachO &TLOFMacho = |
| 827 | static_cast<TargetLoweringObjectFileMachO &>(getObjFileLowering()); |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 828 | OutStreamer.SwitchSection(TLOFMacho.getTextCoalSection()); |
Jim Laskey | 2ada085 | 2006-11-28 18:21:52 +0000 | [diff] [blame] | 829 | if (TM.getRelocationModel() == Reloc::PIC_) { |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 830 | OutStreamer.SwitchSection( |
| 831 | TLOFMacho.getMachOSection("__TEXT", "__picsymbolstub1", |
| 832 | MCSectionMachO::S_SYMBOL_STUBS | |
| 833 | MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, |
| 834 | 32, SectionKind::getText())); |
Jim Laskey | 2ada085 | 2006-11-28 18:21:52 +0000 | [diff] [blame] | 835 | } else if (TM.getRelocationModel() == Reloc::DynamicNoPIC) { |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 836 | OutStreamer.SwitchSection( |
| 837 | TLOFMacho.getMachOSection("__TEXT","__symbol_stub1", |
| 838 | MCSectionMachO::S_SYMBOL_STUBS | |
| 839 | MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, |
| 840 | 16, SectionKind::getText())); |
Jim Laskey | 2ada085 | 2006-11-28 18:21:52 +0000 | [diff] [blame] | 841 | } |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 842 | OutStreamer.SwitchSection(getObjFileLowering().getTextSection()); |
Nate Begeman | 18ed029 | 2005-07-21 01:25:49 +0000 | [diff] [blame] | 843 | } |
| 844 | |
Anton Korobeynikov | 34da127 | 2008-08-08 18:22:59 +0000 | [diff] [blame] | 845 | bool PPCDarwinAsmPrinter::doFinalization(Module &M) { |
Owen Anderson | a69571c | 2006-05-03 01:29:57 +0000 | [diff] [blame] | 846 | const TargetData *TD = TM.getTargetData(); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 847 | |
Chris Lattner | 7e097e4 | 2006-06-27 01:02:25 +0000 | [diff] [blame] | 848 | bool isPPC64 = TD->getPointerSizeInBits() == 64; |
| 849 | |
Chris Lattner | 2dfddee | 2009-08-03 22:52:21 +0000 | [diff] [blame] | 850 | // Darwin/PPC always uses mach-o. |
| 851 | TargetLoweringObjectFileMachO &TLOFMacho = |
| 852 | static_cast<TargetLoweringObjectFileMachO &>(getObjFileLowering()); |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 853 | MachineModuleInfoMachO &MMIMacho = |
| 854 | MMI->getObjFileInfo<MachineModuleInfoMachO>(); |
Chris Lattner | ff4bc46 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 855 | |
| 856 | const MCSection *LSPSection = 0; |
| 857 | if (!FnStubs.empty()) // .lazy_symbol_pointer |
| 858 | LSPSection = TLOFMacho.getLazySymbolPointerSection(); |
Chris Lattner | ff4bc46 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 859 | |
Misha Brukman | da2b13f | 2004-07-16 20:29:04 +0000 | [diff] [blame] | 860 | // Output stubs for dynamically-linked functions |
Chris Lattner | ea56f10 | 2009-07-15 00:55:58 +0000 | [diff] [blame] | 861 | if (TM.getRelocationModel() == Reloc::PIC_ && !FnStubs.empty()) { |
Chris Lattner | 2dfddee | 2009-08-03 22:52:21 +0000 | [diff] [blame] | 862 | const MCSection *StubSection = |
Chris Lattner | ff4bc46 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 863 | TLOFMacho.getMachOSection("__TEXT", "__picsymbolstub1", |
| 864 | MCSectionMachO::S_SYMBOL_STUBS | |
| 865 | MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, |
| 866 | 32, SectionKind::getText()); |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 867 | // FIXME: This is emitting in nondeterminstic order! |
| 868 | for (DenseMap<const MCSymbol*, FnStubInfo>::iterator I = |
| 869 | FnStubs.begin(), E = FnStubs.end(); I != E; ++I) { |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 870 | OutStreamer.SwitchSection(StubSection); |
Chris Lattner | 7e097e4 | 2006-06-27 01:02:25 +0000 | [diff] [blame] | 871 | EmitAlignment(4); |
Chris Lattner | defd300 | 2009-07-15 02:33:19 +0000 | [diff] [blame] | 872 | const FnStubInfo &Info = I->second; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 873 | O << *Info.Stub << ":\n"; |
| 874 | O << "\t.indirect_symbol " << *I->first << '\n'; |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 875 | O << "\tmflr r0\n"; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 876 | O << "\tbcl 20,31," << *Info.AnonSymbol << '\n'; |
| 877 | O << *Info.AnonSymbol << ":\n"; |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 878 | O << "\tmflr r11\n"; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 879 | O << "\taddis r11,r11,ha16(" << *Info.LazyPtr << '-' << *Info.AnonSymbol |
| 880 | << ")\n"; |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 881 | O << "\tmtlr r0\n"; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 882 | O << (isPPC64 ? "\tldu" : "\tlwzu") << " r12,lo16(" << *Info.LazyPtr |
| 883 | << '-' << *Info.AnonSymbol << ")(r11)\n"; |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 884 | O << "\tmtctr r12\n"; |
| 885 | O << "\tbctr\n"; |
Chris Lattner | fe2fe70 | 2009-07-16 01:23:26 +0000 | [diff] [blame] | 886 | |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 887 | OutStreamer.SwitchSection(LSPSection); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 888 | O << *Info.LazyPtr << ":\n"; |
| 889 | O << "\t.indirect_symbol " << *I->first << '\n'; |
Chris Lattner | 1a87c05 | 2009-07-15 02:36:21 +0000 | [diff] [blame] | 890 | O << (isPPC64 ? "\t.quad" : "\t.long") << " dyld_stub_binding_helper\n"; |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 891 | } |
Chris Lattner | ea56f10 | 2009-07-15 00:55:58 +0000 | [diff] [blame] | 892 | } else if (!FnStubs.empty()) { |
Chris Lattner | ff4bc46 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 893 | const MCSection *StubSection = |
| 894 | TLOFMacho.getMachOSection("__TEXT","__symbol_stub1", |
| 895 | MCSectionMachO::S_SYMBOL_STUBS | |
| 896 | MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS, |
| 897 | 16, SectionKind::getText()); |
Chris Lattner | 2dfddee | 2009-08-03 22:52:21 +0000 | [diff] [blame] | 898 | |
Chris Lattner | a40128c | 2010-01-16 02:00:23 +0000 | [diff] [blame] | 899 | // FIXME: This is emitting in nondeterminstic order! |
| 900 | for (DenseMap<const MCSymbol*, FnStubInfo>::iterator I = FnStubs.begin(), |
| 901 | E = FnStubs.end(); I != E; ++I) { |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 902 | OutStreamer.SwitchSection(StubSection); |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 903 | EmitAlignment(4); |
Chris Lattner | defd300 | 2009-07-15 02:33:19 +0000 | [diff] [blame] | 904 | const FnStubInfo &Info = I->second; |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 905 | O << *Info.Stub << ":\n"; |
| 906 | O << "\t.indirect_symbol " << *I->first << '\n'; |
| 907 | O << "\tlis r11,ha16(" << *Info.LazyPtr << ")\n"; |
| 908 | O << (isPPC64 ? "\tldu" : "\tlwzu") << " r12,lo16(" << *Info.LazyPtr |
| 909 | << ")(r11)\n"; |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 910 | O << "\tmtctr r12\n"; |
| 911 | O << "\tbctr\n"; |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 912 | OutStreamer.SwitchSection(LSPSection); |
Chris Lattner | 10b318b | 2010-01-17 21:43:43 +0000 | [diff] [blame] | 913 | O << *Info.LazyPtr << ":\n"; |
| 914 | O << "\t.indirect_symbol " << *I->first << '\n'; |
Chris Lattner | 1a87c05 | 2009-07-15 02:36:21 +0000 | [diff] [blame] | 915 | O << (isPPC64 ? "\t.quad" : "\t.long") << " dyld_stub_binding_helper\n"; |
Nate Begeman | 2497e63 | 2005-07-21 20:44:43 +0000 | [diff] [blame] | 916 | } |
Misha Brukman | 46fd00a | 2004-06-24 23:04:11 +0000 | [diff] [blame] | 917 | } |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 918 | |
Anton Korobeynikov | 382f002 | 2008-08-08 18:24:10 +0000 | [diff] [blame] | 919 | O << '\n'; |
Misha Brukman | da2b13f | 2004-07-16 20:29:04 +0000 | [diff] [blame] | 920 | |
Chris Lattner | 33adcfb | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 921 | if (MAI->doesSupportExceptionHandling() && MMI) { |
Dale Johannesen | 1d4ce2a | 2007-11-20 23:24:42 +0000 | [diff] [blame] | 922 | // Add the (possibly multiple) personalities to the set of global values. |
Dale Johannesen | 1532f3d | 2008-04-02 00:25:04 +0000 | [diff] [blame] | 923 | // Only referenced functions get into the Personalities list. |
Chris Lattner | 0de1fc4 | 2009-06-24 19:09:55 +0000 | [diff] [blame] | 924 | const std::vector<Function *> &Personalities = MMI->getPersonalities(); |
Dale Johannesen | 1d4ce2a | 2007-11-20 23:24:42 +0000 | [diff] [blame] | 925 | for (std::vector<Function *>::const_iterator I = Personalities.begin(), |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 926 | E = Personalities.end(); I != E; ++I) { |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 927 | if (*I) { |
| 928 | const MCSymbol *NLPSym = |
Chris Lattner | 7a2ba94 | 2010-01-16 18:37:32 +0000 | [diff] [blame] | 929 | GetSymbolWithGlobalValueBase(*I, "$non_lazy_ptr"); |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 930 | const MCSymbol *&StubSym = MMIMacho.getGVStubEntry(NLPSym); |
| 931 | StubSym = GetGlobalValueSymbol(*I); |
| 932 | } |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 933 | } |
Dale Johannesen | 1d4ce2a | 2007-11-20 23:24:42 +0000 | [diff] [blame] | 934 | } |
| 935 | |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 936 | // Output stubs for dynamically-linked functions. |
| 937 | MachineModuleInfoMachO::SymbolListTy Stubs = MMIMacho.GetGVStubList(); |
| 938 | |
Chris Lattner | 2dfddee | 2009-08-03 22:52:21 +0000 | [diff] [blame] | 939 | // Output macho stubs for external and common global variables. |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 940 | if (!Stubs.empty()) { |
Chris Lattner | ff4bc46 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 941 | // Switch with ".non_lazy_symbol_pointer" directive. |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 942 | OutStreamer.SwitchSection(TLOFMacho.getNonLazySymbolPointerSection()); |
Chris Lattner | e1e8a82 | 2009-08-10 17:58:51 +0000 | [diff] [blame] | 943 | EmitAlignment(isPPC64 ? 3 : 2); |
| 944 | |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 945 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
| 946 | O << *Stubs[i].first << ":\n"; |
| 947 | O << "\t.indirect_symbol " << *Stubs[i].second << '\n'; |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 948 | O << (isPPC64 ? "\t.quad\t0\n" : "\t.long\t0\n"); |
Chris Lattner | deea416 | 2005-12-13 04:33:58 +0000 | [diff] [blame] | 949 | } |
Nate Begeman | e59bf59 | 2004-08-14 22:09:10 +0000 | [diff] [blame] | 950 | } |
Misha Brukman | b5f662f | 2005-04-21 23:30:14 +0000 | [diff] [blame] | 951 | |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 952 | Stubs = MMIMacho.GetHiddenGVStubList(); |
| 953 | if (!Stubs.empty()) { |
Chris Lattner | 6c2f9e1 | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 954 | OutStreamer.SwitchSection(getObjFileLowering().getDataSection()); |
Chris Lattner | 8f831cb | 2009-07-15 01:14:44 +0000 | [diff] [blame] | 955 | EmitAlignment(isPPC64 ? 3 : 2); |
Chris Lattner | d3ec0b5 | 2010-01-20 21:16:14 +0000 | [diff] [blame^] | 956 | |
| 957 | for (unsigned i = 0, e = Stubs.size(); i != e; ++i) { |
| 958 | O << *Stubs[i].first << ":\n"; |
| 959 | O << (isPPC64 ? "\t.quad\t" : "\t.long\t") << *Stubs[i].second << '\n'; |
Evan Cheng | ae94e59 | 2008-12-05 01:06:39 +0000 | [diff] [blame] | 960 | } |
| 961 | } |
| 962 | |
Chris Lattner | 5b0ac99 | 2005-11-01 00:12:36 +0000 | [diff] [blame] | 963 | // Funny Darwin hack: This flag tells the linker that no global symbols |
| 964 | // contain code that falls through to other global symbols (e.g. the obvious |
| 965 | // implementation of multiple entry points). If this doesn't occur, the |
| 966 | // linker can safely perform dead code stripping. Since LLVM never generates |
| 967 | // code that does this, it is always safe to set. |
Chris Lattner | 74cd3b7 | 2009-10-19 18:03:08 +0000 | [diff] [blame] | 968 | OutStreamer.EmitAssemblerFlag(MCStreamer::SubsectionsViaSymbols); |
Chris Lattner | 5b0ac99 | 2005-11-01 00:12:36 +0000 | [diff] [blame] | 969 | |
Dan Gohman | b8275a3 | 2007-07-25 19:33:14 +0000 | [diff] [blame] | 970 | return AsmPrinter::doFinalization(M); |
Misha Brukman | 5dfe3a9 | 2004-06-21 16:55:25 +0000 | [diff] [blame] | 971 | } |
Nate Begeman | ed42853 | 2004-09-04 05:00:00 +0000 | [diff] [blame] | 972 | |
Chris Lattner | 4da1c82 | 2006-09-20 17:12:19 +0000 | [diff] [blame] | 973 | |
| 974 | |
Jim Laskey | b608a4d | 2006-12-20 20:56:46 +0000 | [diff] [blame] | 975 | /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code |
| 976 | /// for a MachineFunction to the given output stream, in a format that the |
Chris Lattner | 4da1c82 | 2006-09-20 17:12:19 +0000 | [diff] [blame] | 977 | /// Darwin assembler can deal with. |
| 978 | /// |
Daniel Dunbar | 7894578 | 2009-08-13 23:48:47 +0000 | [diff] [blame] | 979 | static AsmPrinter *createPPCAsmPrinterPass(formatted_raw_ostream &o, |
| 980 | TargetMachine &tm, |
Chris Lattner | af76e59 | 2009-08-22 20:48:53 +0000 | [diff] [blame] | 981 | const MCAsmInfo *tai, |
Daniel Dunbar | 7894578 | 2009-08-13 23:48:47 +0000 | [diff] [blame] | 982 | bool verbose) { |
Jim Laskey | bf11182 | 2006-12-21 20:26:09 +0000 | [diff] [blame] | 983 | const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>(); |
| 984 | |
Chris Lattner | 40bbebd | 2009-07-21 18:38:57 +0000 | [diff] [blame] | 985 | if (Subtarget->isDarwin()) |
Daniel Dunbar | 67d894e | 2009-08-13 19:38:51 +0000 | [diff] [blame] | 986 | return new PPCDarwinAsmPrinter(o, tm, tai, verbose); |
| 987 | return new PPCLinuxAsmPrinter(o, tm, tai, verbose); |
Chris Lattner | 4da1c82 | 2006-09-20 17:12:19 +0000 | [diff] [blame] | 988 | } |
Anton Korobeynikov | 06be997 | 2008-08-17 13:54:28 +0000 | [diff] [blame] | 989 | |
Bob Wilson | a96751f | 2009-06-23 23:59:40 +0000 | [diff] [blame] | 990 | // Force static initialization. |
Daniel Dunbar | 51b198a | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 991 | extern "C" void LLVMInitializePowerPCAsmPrinter() { |
Daniel Dunbar | 51b198a | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 992 | TargetRegistry::RegisterAsmPrinter(ThePPC32Target, createPPCAsmPrinterPass); |
Daniel Dunbar | 51b198a | 2009-07-15 20:24:03 +0000 | [diff] [blame] | 993 | TargetRegistry::RegisterAsmPrinter(ThePPC64Target, createPPCAsmPrinterPass); |
| 994 | } |