XCoreAsmPrinter.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
1//===-- XCoreAsmPrinter.cpp - XCore LLVM assembly writer ------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains a printer that converts from our internal representation 11// of machine-dependent LLVM code to the XAS-format XCore assembly language. 12// 13//===----------------------------------------------------------------------===// 14 15#define DEBUG_TYPE "asm-printer" 16#include "XCore.h" 17#include "InstPrinter/XCoreInstPrinter.h" 18#include "XCoreInstrInfo.h" 19#include "XCoreMCInstLower.h" 20#include "XCoreSubtarget.h" 21#include "XCoreTargetMachine.h" 22#include "XCoreTargetStreamer.h" 23#include "llvm/ADT/SmallString.h" 24#include "llvm/ADT/StringExtras.h" 25#include "llvm/CodeGen/AsmPrinter.h" 26#include "llvm/CodeGen/MachineConstantPool.h" 27#include "llvm/CodeGen/MachineFunctionPass.h" 28#include "llvm/CodeGen/MachineInstr.h" 29#include "llvm/CodeGen/MachineJumpTableInfo.h" 30#include "llvm/CodeGen/MachineModuleInfo.h" 31#include "llvm/IR/Constants.h" 32#include "llvm/IR/DataLayout.h" 33#include "llvm/IR/DebugInfo.h" 34#include "llvm/IR/DerivedTypes.h" 35#include "llvm/IR/Mangler.h" 36#include "llvm/IR/Module.h" 37#include "llvm/MC/MCAsmInfo.h" 38#include "llvm/MC/MCExpr.h" 39#include "llvm/MC/MCInst.h" 40#include "llvm/MC/MCStreamer.h" 41#include "llvm/MC/MCSymbol.h" 42#include "llvm/Support/ErrorHandling.h" 43#include "llvm/Support/TargetRegistry.h" 44#include "llvm/Support/raw_ostream.h" 45#include "llvm/Target/TargetLoweringObjectFile.h" 46#include <algorithm> 47#include <cctype> 48using namespace llvm; 49 50namespace { 51 class XCoreAsmPrinter : public AsmPrinter { 52 const XCoreSubtarget &Subtarget; 53 XCoreMCInstLower MCInstLowering; 54 XCoreTargetStreamer &getTargetStreamer(); 55 56 public: 57 explicit XCoreAsmPrinter(TargetMachine &TM, MCStreamer &Streamer) 58 : AsmPrinter(TM, Streamer), Subtarget(TM.getSubtarget<XCoreSubtarget>()), 59 MCInstLowering(*this) {} 60 61 virtual const char *getPassName() const { 62 return "XCore Assembly Printer"; 63 } 64 65 void printInlineJT(const MachineInstr *MI, int opNum, raw_ostream &O, 66 const std::string &directive = ".jmptable"); 67 void printInlineJT32(const MachineInstr *MI, int opNum, raw_ostream &O) { 68 printInlineJT(MI, opNum, O, ".jmptable32"); 69 } 70 void printOperand(const MachineInstr *MI, int opNum, raw_ostream &O); 71 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 72 unsigned AsmVariant, const char *ExtraCode, 73 raw_ostream &O); 74 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum, 75 unsigned AsmVariant, const char *ExtraCode, 76 raw_ostream &O) override; 77 78 void emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV); 79 virtual void EmitGlobalVariable(const GlobalVariable *GV); 80 81 void EmitFunctionEntryLabel(); 82 void EmitInstruction(const MachineInstr *MI); 83 void EmitFunctionBodyStart(); 84 void EmitFunctionBodyEnd(); 85 }; 86} // end of anonymous namespace 87 88XCoreTargetStreamer &XCoreAsmPrinter::getTargetStreamer() { 89 return static_cast<XCoreTargetStreamer&>(*OutStreamer.getTargetStreamer()); 90} 91 92void XCoreAsmPrinter::emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV) { 93 assert( ( GV->hasExternalLinkage() || GV->hasWeakLinkage() || 94 GV->hasLinkOnceLinkage() || GV->hasCommonLinkage() ) && 95 "Unexpected linkage"); 96 if (ArrayType *ATy = dyn_cast<ArrayType>( 97 cast<PointerType>(GV->getType())->getElementType())) { 98 99 MCSymbol *SymGlob = OutContext.GetOrCreateSymbol( 100 Twine(Sym->getName() + StringRef(".globound"))); 101 OutStreamer.EmitSymbolAttribute(SymGlob, MCSA_Global); 102 OutStreamer.EmitAssignment(SymGlob, 103 MCConstantExpr::Create(ATy->getNumElements(), 104 OutContext)); 105 if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() || 106 GV->hasCommonLinkage()) { 107 // TODO Use COMDAT groups for LinkOnceLinkage 108 OutStreamer.EmitSymbolAttribute(SymGlob, MCSA_Weak); 109 } 110 } 111} 112 113void XCoreAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { 114 // Check to see if this is a special global used by LLVM, if so, emit it. 115 if (!GV->hasInitializer() || 116 EmitSpecialLLVMGlobal(GV)) 117 return; 118 119 const DataLayout *TD = TM.getDataLayout(); 120 OutStreamer.SwitchSection( 121 getObjFileLowering().SectionForGlobal(GV, *Mang, TM)); 122 123 MCSymbol *GVSym = getSymbol(GV); 124 const Constant *C = GV->getInitializer(); 125 unsigned Align = (unsigned)TD->getPreferredTypeAlignmentShift(C->getType()); 126 127 // Mark the start of the global 128 getTargetStreamer().emitCCTopData(GVSym->getName()); 129 130 switch (GV->getLinkage()) { 131 case GlobalValue::AppendingLinkage: 132 report_fatal_error("AppendingLinkage is not supported by this target!"); 133 case GlobalValue::LinkOnceAnyLinkage: 134 case GlobalValue::LinkOnceODRLinkage: 135 case GlobalValue::WeakAnyLinkage: 136 case GlobalValue::WeakODRLinkage: 137 case GlobalValue::ExternalLinkage: 138 case GlobalValue::CommonLinkage: 139 emitArrayBound(GVSym, GV); 140 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 141 142 // TODO Use COMDAT groups for LinkOnceLinkage 143 if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() || 144 GV->hasCommonLinkage()) 145 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); 146 // FALL THROUGH 147 case GlobalValue::InternalLinkage: 148 case GlobalValue::PrivateLinkage: 149 break; 150 default: 151 llvm_unreachable("Unknown linkage type!"); 152 } 153 154 EmitAlignment(Align > 2 ? Align : 2, GV); 155 156 if (GV->isThreadLocal()) { 157 report_fatal_error("TLS is not supported by this target!"); 158 } 159 unsigned Size = TD->getTypeAllocSize(C->getType()); 160 if (MAI->hasDotTypeDotSizeDirective()) { 161 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); 162 OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext)); 163 } 164 OutStreamer.EmitLabel(GVSym); 165 166 EmitGlobalConstant(C); 167 // The ABI requires that unsigned scalar types smaller than 32 bits 168 // are padded to 32 bits. 169 if (Size < 4) 170 OutStreamer.EmitZeros(4 - Size); 171 172 // Mark the end of the global 173 getTargetStreamer().emitCCBottomData(GVSym->getName()); 174} 175 176void XCoreAsmPrinter::EmitFunctionBodyStart() { 177 MCInstLowering.Initialize(Mang, &MF->getContext()); 178} 179 180/// EmitFunctionBodyEnd - Targets can override this to emit stuff after 181/// the last basic block in the function. 182void XCoreAsmPrinter::EmitFunctionBodyEnd() { 183 // Emit function end directives 184 getTargetStreamer().emitCCBottomFunction(CurrentFnSym->getName()); 185} 186 187void XCoreAsmPrinter::EmitFunctionEntryLabel() { 188 // Mark the start of the function 189 getTargetStreamer().emitCCTopFunction(CurrentFnSym->getName()); 190 OutStreamer.EmitLabel(CurrentFnSym); 191} 192 193void XCoreAsmPrinter:: 194printInlineJT(const MachineInstr *MI, int opNum, raw_ostream &O, 195 const std::string &directive) { 196 unsigned JTI = MI->getOperand(opNum).getIndex(); 197 const MachineFunction *MF = MI->getParent()->getParent(); 198 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); 199 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 200 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; 201 O << "\t" << directive << " "; 202 for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) { 203 MachineBasicBlock *MBB = JTBBs[i]; 204 if (i > 0) 205 O << ","; 206 O << *MBB->getSymbol(); 207 } 208} 209 210void XCoreAsmPrinter::printOperand(const MachineInstr *MI, int opNum, 211 raw_ostream &O) { 212 const DataLayout *DL = TM.getDataLayout(); 213 const MachineOperand &MO = MI->getOperand(opNum); 214 switch (MO.getType()) { 215 case MachineOperand::MO_Register: 216 O << XCoreInstPrinter::getRegisterName(MO.getReg()); 217 break; 218 case MachineOperand::MO_Immediate: 219 O << MO.getImm(); 220 break; 221 case MachineOperand::MO_MachineBasicBlock: 222 O << *MO.getMBB()->getSymbol(); 223 break; 224 case MachineOperand::MO_GlobalAddress: 225 O << *getSymbol(MO.getGlobal()); 226 break; 227 case MachineOperand::MO_ConstantPoolIndex: 228 O << DL->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() 229 << '_' << MO.getIndex(); 230 break; 231 case MachineOperand::MO_BlockAddress: 232 O << *GetBlockAddressSymbol(MO.getBlockAddress()); 233 break; 234 default: 235 llvm_unreachable("not implemented"); 236 } 237} 238 239/// PrintAsmOperand - Print out an operand for an inline asm expression. 240/// 241bool XCoreAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 242 unsigned AsmVariant,const char *ExtraCode, 243 raw_ostream &O) { 244 // Print the operand if there is no operand modifier. 245 if (!ExtraCode || !ExtraCode[0]) { 246 printOperand(MI, OpNo, O); 247 return false; 248 } 249 250 // Otherwise fallback on the default implementation. 251 return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O); 252} 253 254bool XCoreAsmPrinter:: 255PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum, 256 unsigned AsmVariant, const char *ExtraCode, 257 raw_ostream &O) { 258 if (ExtraCode && ExtraCode[0]) { 259 return true; // Unknown modifier. 260 } 261 printOperand(MI, OpNum, O); 262 O << '['; 263 printOperand(MI, OpNum + 1, O); 264 O << ']'; 265 return false; 266} 267 268void XCoreAsmPrinter::EmitInstruction(const MachineInstr *MI) { 269 SmallString<128> Str; 270 raw_svector_ostream O(Str); 271 272 switch (MI->getOpcode()) { 273 case XCore::DBG_VALUE: 274 llvm_unreachable("Should be handled target independently"); 275 case XCore::ADD_2rus: 276 if (MI->getOperand(2).getImm() == 0) { 277 O << "\tmov " 278 << XCoreInstPrinter::getRegisterName(MI->getOperand(0).getReg()) << ", " 279 << XCoreInstPrinter::getRegisterName(MI->getOperand(1).getReg()); 280 OutStreamer.EmitRawText(O.str()); 281 return; 282 } 283 break; 284 case XCore::BR_JT: 285 case XCore::BR_JT32: 286 O << "\tbru " 287 << XCoreInstPrinter::getRegisterName(MI->getOperand(1).getReg()) << '\n'; 288 if (MI->getOpcode() == XCore::BR_JT) 289 printInlineJT(MI, 0, O); 290 else 291 printInlineJT32(MI, 0, O); 292 O << '\n'; 293 OutStreamer.EmitRawText(O.str()); 294 return; 295 } 296 297 MCInst TmpInst; 298 MCInstLowering.Lower(MI, TmpInst); 299 300 EmitToStreamer(OutStreamer, TmpInst); 301} 302 303// Force static initialization. 304extern "C" void LLVMInitializeXCoreAsmPrinter() { 305 RegisterAsmPrinter<XCoreAsmPrinter> X(TheXCoreTarget); 306} 307