XCoreAsmPrinter.cpp revision 249423
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 "llvm/ADT/SmallString.h" 23#include "llvm/ADT/StringExtras.h" 24#include "llvm/CodeGen/AsmPrinter.h" 25#include "llvm/CodeGen/MachineConstantPool.h" 26#include "llvm/CodeGen/MachineFunctionPass.h" 27#include "llvm/CodeGen/MachineInstr.h" 28#include "llvm/CodeGen/MachineJumpTableInfo.h" 29#include "llvm/CodeGen/MachineModuleInfo.h" 30#include "llvm/DebugInfo.h" 31#include "llvm/IR/Constants.h" 32#include "llvm/IR/DataLayout.h" 33#include "llvm/IR/DerivedTypes.h" 34#include "llvm/IR/Module.h" 35#include "llvm/MC/MCAsmInfo.h" 36#include "llvm/MC/MCInst.h" 37#include "llvm/MC/MCStreamer.h" 38#include "llvm/MC/MCSymbol.h" 39#include "llvm/Support/CommandLine.h" 40#include "llvm/Support/ErrorHandling.h" 41#include "llvm/Support/TargetRegistry.h" 42#include "llvm/Support/raw_ostream.h" 43#include "llvm/Target/Mangler.h" 44#include "llvm/Target/TargetLoweringObjectFile.h" 45#include <algorithm> 46#include <cctype> 47using namespace llvm; 48 49static cl::opt<unsigned> MaxThreads("xcore-max-threads", cl::Optional, 50 cl::desc("Maximum number of threads (for emulation thread-local storage)"), 51 cl::Hidden, 52 cl::value_desc("number"), 53 cl::init(8)); 54 55namespace { 56 class XCoreAsmPrinter : public AsmPrinter { 57 const XCoreSubtarget &Subtarget; 58 XCoreMCInstLower MCInstLowering; 59 void PrintDebugValueComment(const MachineInstr *MI, raw_ostream &OS); 60 public: 61 explicit XCoreAsmPrinter(TargetMachine &TM, MCStreamer &Streamer) 62 : AsmPrinter(TM, Streamer), Subtarget(TM.getSubtarget<XCoreSubtarget>()), 63 MCInstLowering(*this) {} 64 65 virtual const char *getPassName() const { 66 return "XCore Assembly Printer"; 67 } 68 69 void printInlineJT(const MachineInstr *MI, int opNum, raw_ostream &O, 70 const std::string &directive = ".jmptable"); 71 void printInlineJT32(const MachineInstr *MI, int opNum, raw_ostream &O) { 72 printInlineJT(MI, opNum, O, ".jmptable32"); 73 } 74 void printOperand(const MachineInstr *MI, int opNum, raw_ostream &O); 75 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 76 unsigned AsmVariant, const char *ExtraCode, 77 raw_ostream &O); 78 79 void emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV); 80 virtual void EmitGlobalVariable(const GlobalVariable *GV); 81 82 void EmitFunctionEntryLabel(); 83 void EmitInstruction(const MachineInstr *MI); 84 void EmitFunctionBodyStart(); 85 void EmitFunctionBodyEnd(); 86 virtual MachineLocation getDebugValueLocation(const MachineInstr *MI) const; 87 }; 88} // end of anonymous namespace 89 90void XCoreAsmPrinter::emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV) { 91 assert(((GV->hasExternalLinkage() || 92 GV->hasWeakLinkage()) || 93 GV->hasLinkOnceLinkage()) && "Unexpected linkage"); 94 if (ArrayType *ATy = dyn_cast<ArrayType>( 95 cast<PointerType>(GV->getType())->getElementType())) { 96 OutStreamer.EmitSymbolAttribute(Sym, MCSA_Global); 97 // FIXME: MCStreamerize. 98 OutStreamer.EmitRawText(StringRef(".globound")); 99 OutStreamer.EmitRawText("\t.set\t" + Twine(Sym->getName())); 100 OutStreamer.EmitRawText(".globound," + Twine(ATy->getNumElements())); 101 if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage()) { 102 // TODO Use COMDAT groups for LinkOnceLinkage 103 OutStreamer.EmitRawText(MAI->getWeakDefDirective() +Twine(Sym->getName())+ 104 ".globound"); 105 } 106 } 107} 108 109void XCoreAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { 110 // Check to see if this is a special global used by LLVM, if so, emit it. 111 if (!GV->hasInitializer() || 112 EmitSpecialLLVMGlobal(GV)) 113 return; 114 115 const DataLayout *TD = TM.getDataLayout(); 116 OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(GV, Mang,TM)); 117 118 119 MCSymbol *GVSym = Mang->getSymbol(GV); 120 const Constant *C = GV->getInitializer(); 121 unsigned Align = (unsigned)TD->getPreferredTypeAlignmentShift(C->getType()); 122 123 // Mark the start of the global 124 OutStreamer.EmitRawText("\t.cc_top " + Twine(GVSym->getName()) + ".data," + 125 GVSym->getName()); 126 127 switch (GV->getLinkage()) { 128 case GlobalValue::AppendingLinkage: 129 report_fatal_error("AppendingLinkage is not supported by this target!"); 130 case GlobalValue::LinkOnceAnyLinkage: 131 case GlobalValue::LinkOnceODRLinkage: 132 case GlobalValue::WeakAnyLinkage: 133 case GlobalValue::WeakODRLinkage: 134 case GlobalValue::ExternalLinkage: 135 emitArrayBound(GVSym, GV); 136 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 137 138 // TODO Use COMDAT groups for LinkOnceLinkage 139 if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage()) 140 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); 141 // FALL THROUGH 142 case GlobalValue::InternalLinkage: 143 case GlobalValue::PrivateLinkage: 144 break; 145 case GlobalValue::DLLImportLinkage: 146 llvm_unreachable("DLLImport linkage is not supported by this target!"); 147 case GlobalValue::DLLExportLinkage: 148 llvm_unreachable("DLLExport linkage is not supported by this target!"); 149 default: 150 llvm_unreachable("Unknown linkage type!"); 151 } 152 153 EmitAlignment(Align > 2 ? Align : 2, GV); 154 155 unsigned Size = TD->getTypeAllocSize(C->getType()); 156 if (GV->isThreadLocal()) { 157 Size *= MaxThreads; 158 } 159 if (MAI->hasDotTypeDotSizeDirective()) { 160 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); 161 OutStreamer.EmitRawText("\t.size " + Twine(GVSym->getName()) + "," + 162 Twine(Size)); 163 } 164 OutStreamer.EmitLabel(GVSym); 165 166 EmitGlobalConstant(C); 167 if (GV->isThreadLocal()) { 168 for (unsigned i = 1; i < MaxThreads; ++i) 169 EmitGlobalConstant(C); 170 } 171 // The ABI requires that unsigned scalar types smaller than 32 bits 172 // are padded to 32 bits. 173 if (Size < 4) 174 OutStreamer.EmitZeros(4 - Size); 175 176 // Mark the end of the global 177 OutStreamer.EmitRawText("\t.cc_bottom " + Twine(GVSym->getName()) + ".data"); 178} 179 180void XCoreAsmPrinter::EmitFunctionBodyStart() { 181 MCInstLowering.Initialize(Mang, &MF->getContext()); 182} 183 184/// EmitFunctionBodyEnd - Targets can override this to emit stuff after 185/// the last basic block in the function. 186void XCoreAsmPrinter::EmitFunctionBodyEnd() { 187 // Emit function end directives 188 OutStreamer.EmitRawText("\t.cc_bottom " + Twine(CurrentFnSym->getName()) + 189 ".function"); 190} 191 192void XCoreAsmPrinter::EmitFunctionEntryLabel() { 193 // Mark the start of the function 194 OutStreamer.EmitRawText("\t.cc_top " + Twine(CurrentFnSym->getName()) + 195 ".function," + CurrentFnSym->getName()); 196 OutStreamer.EmitLabel(CurrentFnSym); 197} 198 199void XCoreAsmPrinter:: 200printInlineJT(const MachineInstr *MI, int opNum, raw_ostream &O, 201 const std::string &directive) { 202 unsigned JTI = MI->getOperand(opNum).getIndex(); 203 const MachineFunction *MF = MI->getParent()->getParent(); 204 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); 205 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 206 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; 207 O << "\t" << directive << " "; 208 for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) { 209 MachineBasicBlock *MBB = JTBBs[i]; 210 if (i > 0) 211 O << ","; 212 O << *MBB->getSymbol(); 213 } 214} 215 216void XCoreAsmPrinter::printOperand(const MachineInstr *MI, int opNum, 217 raw_ostream &O) { 218 const MachineOperand &MO = MI->getOperand(opNum); 219 switch (MO.getType()) { 220 case MachineOperand::MO_Register: 221 O << XCoreInstPrinter::getRegisterName(MO.getReg()); 222 break; 223 case MachineOperand::MO_Immediate: 224 O << MO.getImm(); 225 break; 226 case MachineOperand::MO_MachineBasicBlock: 227 O << *MO.getMBB()->getSymbol(); 228 break; 229 case MachineOperand::MO_GlobalAddress: 230 O << *Mang->getSymbol(MO.getGlobal()); 231 break; 232 case MachineOperand::MO_ExternalSymbol: 233 O << MO.getSymbolName(); 234 break; 235 case MachineOperand::MO_ConstantPoolIndex: 236 O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() 237 << '_' << MO.getIndex(); 238 break; 239 case MachineOperand::MO_JumpTableIndex: 240 O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() 241 << '_' << MO.getIndex(); 242 break; 243 case MachineOperand::MO_BlockAddress: 244 O << *GetBlockAddressSymbol(MO.getBlockAddress()); 245 break; 246 default: 247 llvm_unreachable("not implemented"); 248 } 249} 250 251/// PrintAsmOperand - Print out an operand for an inline asm expression. 252/// 253bool XCoreAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 254 unsigned AsmVariant,const char *ExtraCode, 255 raw_ostream &O) { 256 // Does this asm operand have a single letter operand modifier? 257 if (ExtraCode && ExtraCode[0]) 258 if (ExtraCode[1] != 0) return true; // Unknown modifier. 259 260 switch (ExtraCode[0]) { 261 default: 262 // See if this is a generic print operand 263 return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O); 264 } 265 266 printOperand(MI, OpNo, O); 267 return false; 268} 269 270void XCoreAsmPrinter::PrintDebugValueComment(const MachineInstr *MI, 271 raw_ostream &OS) { 272 unsigned NOps = MI->getNumOperands(); 273 assert(NOps == 4); 274 OS << '\t' << MAI->getCommentString() << "DEBUG_VALUE: "; 275 // cast away const; DIetc do not take const operands for some reason. 276 DIVariable V(const_cast<MDNode *>(MI->getOperand(NOps-1).getMetadata())); 277 OS << V.getName(); 278 OS << " <- "; 279 // Frame address. Currently handles register +- offset only. 280 assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm()); 281 OS << '['; printOperand(MI, 0, OS); OS << '+'; printOperand(MI, 1, OS); 282 OS << ']'; 283 OS << "+"; 284 printOperand(MI, NOps-2, OS); 285} 286 287MachineLocation XCoreAsmPrinter:: 288getDebugValueLocation(const MachineInstr *MI) const { 289 // Handles frame addresses emitted in XCoreInstrInfo::emitFrameIndexDebugValue. 290 assert(MI->getNumOperands() == 4 && "Invalid no. of machine operands!"); 291 assert(MI->getOperand(0).isReg() && MI->getOperand(1).isImm() && 292 "Unexpected MachineOperand types"); 293 return MachineLocation(MI->getOperand(0).getReg(), 294 MI->getOperand(1).getImm()); 295} 296 297void XCoreAsmPrinter::EmitInstruction(const MachineInstr *MI) { 298 SmallString<128> Str; 299 raw_svector_ostream O(Str); 300 301 switch (MI->getOpcode()) { 302 case XCore::DBG_VALUE: { 303 if (isVerbose() && OutStreamer.hasRawTextSupport()) { 304 SmallString<128> TmpStr; 305 raw_svector_ostream OS(TmpStr); 306 PrintDebugValueComment(MI, OS); 307 OutStreamer.EmitRawText(StringRef(OS.str())); 308 } 309 return; 310 } 311 case XCore::ADD_2rus: 312 if (MI->getOperand(2).getImm() == 0) { 313 O << "\tmov " 314 << XCoreInstPrinter::getRegisterName(MI->getOperand(0).getReg()) << ", " 315 << XCoreInstPrinter::getRegisterName(MI->getOperand(1).getReg()); 316 OutStreamer.EmitRawText(O.str()); 317 return; 318 } 319 break; 320 case XCore::BR_JT: 321 case XCore::BR_JT32: 322 O << "\tbru " 323 << XCoreInstPrinter::getRegisterName(MI->getOperand(1).getReg()) << '\n'; 324 if (MI->getOpcode() == XCore::BR_JT) 325 printInlineJT(MI, 0, O); 326 else 327 printInlineJT32(MI, 0, O); 328 O << '\n'; 329 OutStreamer.EmitRawText(O.str()); 330 return; 331 } 332 333 MCInst TmpInst; 334 MCInstLowering.Lower(MI, TmpInst); 335 336 OutStreamer.EmitInstruction(TmpInst); 337} 338 339// Force static initialization. 340extern "C" void LLVMInitializeXCoreAsmPrinter() { 341 RegisterAsmPrinter<XCoreAsmPrinter> X(TheXCoreTarget); 342} 343