1 //===-- SystemZAsmPrinter.cpp - SystemZ LLVM assembly writer ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains a printer that converts from our internal representation
11 // of machine-dependent LLVM code to the SystemZ assembly language.
13 //===----------------------------------------------------------------------===//
15 #define DEBUG_TYPE "asm-printer"
17 #include "SystemZInstrInfo.h"
18 #include "SystemZTargetMachine.h"
19 #include "llvm/Constants.h"
20 #include "llvm/DerivedTypes.h"
21 #include "llvm/Module.h"
22 #include "llvm/Assembly/Writer.h"
23 #include "llvm/CodeGen/AsmPrinter.h"
24 #include "llvm/CodeGen/MachineModuleInfo.h"
25 #include "llvm/CodeGen/MachineFunctionPass.h"
26 #include "llvm/CodeGen/MachineConstantPool.h"
27 #include "llvm/MC/MCStreamer.h"
28 #include "llvm/MC/MCAsmInfo.h"
29 #include "llvm/MC/MCSymbol.h"
30 #include "llvm/Target/Mangler.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/Support/TargetRegistry.h"
33 #include "llvm/Support/raw_ostream.h"
37 class SystemZAsmPrinter : public AsmPrinter {
39 SystemZAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
40 : AsmPrinter(TM, Streamer) {}
42 virtual const char *getPassName() const {
43 return "SystemZ Assembly Printer";
46 void printOperand(const MachineInstr *MI, int OpNum, raw_ostream &O,
47 const char* Modifier = 0);
48 void printPCRelImmOperand(const MachineInstr *MI, int OpNum, raw_ostream &O);
49 void printRIAddrOperand(const MachineInstr *MI, int OpNum, raw_ostream &O,
50 const char* Modifier = 0);
51 void printRRIAddrOperand(const MachineInstr *MI, int OpNum, raw_ostream &O,
52 const char* Modifier = 0);
53 void printS16ImmOperand(const MachineInstr *MI, int OpNum, raw_ostream &O) {
54 O << (int16_t)MI->getOperand(OpNum).getImm();
56 void printU16ImmOperand(const MachineInstr *MI, int OpNum, raw_ostream &O) {
57 O << (uint16_t)MI->getOperand(OpNum).getImm();
59 void printS32ImmOperand(const MachineInstr *MI, int OpNum, raw_ostream &O) {
60 O << (int32_t)MI->getOperand(OpNum).getImm();
62 void printU32ImmOperand(const MachineInstr *MI, int OpNum, raw_ostream &O) {
63 O << (uint32_t)MI->getOperand(OpNum).getImm();
66 void printInstruction(const MachineInstr *MI, raw_ostream &O);
67 static const char *getRegisterName(unsigned RegNo);
69 void EmitInstruction(const MachineInstr *MI);
71 } // end of anonymous namespace
73 #include "SystemZGenAsmWriter.inc"
75 void SystemZAsmPrinter::EmitInstruction(const MachineInstr *MI) {
77 raw_svector_ostream OS(Str);
78 printInstruction(MI, OS);
79 OutStreamer.EmitRawText(OS.str());
82 void SystemZAsmPrinter::printPCRelImmOperand(const MachineInstr *MI, int OpNum,
84 const MachineOperand &MO = MI->getOperand(OpNum);
85 switch (MO.getType()) {
86 case MachineOperand::MO_Immediate:
89 case MachineOperand::MO_MachineBasicBlock:
90 O << *MO.getMBB()->getSymbol();
92 case MachineOperand::MO_GlobalAddress: {
93 const GlobalValue *GV = MO.getGlobal();
94 O << *Mang->getSymbol(GV);
96 // Assemble calls via PLT for externally visible symbols if PIC.
97 if (TM.getRelocationModel() == Reloc::PIC_ &&
98 !GV->hasHiddenVisibility() && !GV->hasProtectedVisibility() &&
99 !GV->hasLocalLinkage())
102 printOffset(MO.getOffset(), O);
105 case MachineOperand::MO_ExternalSymbol: {
106 std::string Name(MAI->getGlobalPrefix());
107 Name += MO.getSymbolName();
110 if (TM.getRelocationModel() == Reloc::PIC_)
116 assert(0 && "Not implemented yet!");
121 void SystemZAsmPrinter::printOperand(const MachineInstr *MI, int OpNum,
122 raw_ostream &O, const char *Modifier) {
123 const MachineOperand &MO = MI->getOperand(OpNum);
124 switch (MO.getType()) {
125 case MachineOperand::MO_Register: {
126 assert (TargetRegisterInfo::isPhysicalRegister(MO.getReg()) &&
127 "Virtual registers should be already mapped!");
128 unsigned Reg = MO.getReg();
129 if (Modifier && strncmp(Modifier, "subreg", 6) == 0) {
130 if (strncmp(Modifier + 7, "even", 4) == 0)
131 Reg = TM.getRegisterInfo()->getSubReg(Reg, SystemZ::subreg_32bit);
132 else if (strncmp(Modifier + 7, "odd", 3) == 0)
133 Reg = TM.getRegisterInfo()->getSubReg(Reg, SystemZ::subreg_odd32);
135 assert(0 && "Invalid subreg modifier");
138 O << '%' << getRegisterName(Reg);
141 case MachineOperand::MO_Immediate:
144 case MachineOperand::MO_MachineBasicBlock:
145 O << *MO.getMBB()->getSymbol();
147 case MachineOperand::MO_JumpTableIndex:
148 O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() << '_'
152 case MachineOperand::MO_ConstantPoolIndex:
153 O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
156 printOffset(MO.getOffset(), O);
158 case MachineOperand::MO_GlobalAddress:
159 O << *Mang->getSymbol(MO.getGlobal());
161 case MachineOperand::MO_ExternalSymbol: {
162 O << *GetExternalSymbolSymbol(MO.getSymbolName());
166 assert(0 && "Not implemented yet!");
169 switch (MO.getTargetFlags()) {
170 default: assert(0 && "Unknown target flag on GV operand");
171 case SystemZII::MO_NO_FLAG:
173 case SystemZII::MO_GOTENT: O << "@GOTENT"; break;
174 case SystemZII::MO_PLT: O << "@PLT"; break;
177 printOffset(MO.getOffset(), O);
180 void SystemZAsmPrinter::printRIAddrOperand(const MachineInstr *MI, int OpNum,
182 const char *Modifier) {
183 const MachineOperand &Base = MI->getOperand(OpNum);
185 // Print displacement operand.
186 printOperand(MI, OpNum+1, O);
188 // Print base operand (if any)
191 printOperand(MI, OpNum, O);
196 void SystemZAsmPrinter::printRRIAddrOperand(const MachineInstr *MI, int OpNum,
198 const char *Modifier) {
199 const MachineOperand &Base = MI->getOperand(OpNum);
200 const MachineOperand &Index = MI->getOperand(OpNum+2);
202 // Print displacement operand.
203 printOperand(MI, OpNum+1, O);
205 // Print base operand (if any)
208 printOperand(MI, OpNum, O);
209 if (Index.getReg()) {
211 printOperand(MI, OpNum+2, O);
215 assert(!Index.getReg() && "Should allocate base register first!");
218 // Force static initialization.
219 extern "C" void LLVMInitializeSystemZAsmPrinter() {
220 RegisterAsmPrinter<SystemZAsmPrinter> X(TheSystemZTarget);