lib/Target/Blackfin/AsmPrinter/BlackfinAsmPrinter.cpp

   1 //===-- BlackfinAsmPrinter.cpp - Blackfin 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 GAS-format BLACKFIN assembly language.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "asm-printer"
  16 #include "Blackfin.h"
  17 #include "BlackfinInstrInfo.h"
  18 #include "llvm/Constants.h"
  19 #include "llvm/DerivedTypes.h"
  20 #include "llvm/Module.h"
  21 #include "llvm/CodeGen/AsmPrinter.h"
  22 #include "llvm/CodeGen/DwarfWriter.h"
  23 #include "llvm/CodeGen/MachineFunctionPass.h"
  24 #include "llvm/CodeGen/MachineConstantPool.h"
  25 #include "llvm/CodeGen/MachineInstr.h"
  26 #include "llvm/MC/MCStreamer.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/MC/MCContext.h"
  29 #include "llvm/MC/MCSymbol.h"
  30 #include "llvm/Target/Mangler.h"
  31 #include "llvm/Target/TargetData.h"
  32 #include "llvm/Target/TargetLoweringObjectFile.h"
  33 #include "llvm/Target/TargetRegistry.h"
  34 #include "llvm/ADT/SmallString.h"
  35 #include "llvm/Support/ErrorHandling.h"
  36 #include "llvm/Support/FormattedStream.h"
  37 using namespace llvm;
  38
  39 namespace {
  40   class BlackfinAsmPrinter : public AsmPrinter {
  41   public:
  42     BlackfinAsmPrinter(formatted_raw_ostream &O, TargetMachine &TM,
  43                        MCStreamer &Streamer)
  44       : AsmPrinter(O, TM, Streamer) {}
  45
  46     virtual const char *getPassName() const {
  47       return "Blackfin Assembly Printer";
  48     }
  49
  50     void printOperand(const MachineInstr *MI, int opNum, raw_ostream &O);
  51     void printMemoryOperand(const MachineInstr *MI, int opNum, raw_ostream &O);
  52     void printInstruction(const MachineInstr *MI, raw_ostream &O);// autogen'd.
  53     static const char *getRegisterName(unsigned RegNo);
  54
  55     void EmitInstruction(const MachineInstr *MI) {
  56       printInstruction(MI, O);
  57       OutStreamer.AddBlankLine();
  58     }
  59     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
  60                          unsigned AsmVariant, const char *ExtraCode);
  61     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
  62                                unsigned AsmVariant, const char *ExtraCode);
  63   };
  64 } // end of anonymous namespace
  65
  66 #include "BlackfinGenAsmWriter.inc"
  67
  68 extern "C" void LLVMInitializeBlackfinAsmPrinter() {
  69   RegisterAsmPrinter<BlackfinAsmPrinter> X(TheBlackfinTarget);
  70 }
  71
  72 void BlackfinAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
  73                                       raw_ostream &O) {
  74   const MachineOperand &MO = MI->getOperand(opNum);
  75   switch (MO.getType()) {
  76   case MachineOperand::MO_Register:
  77     assert(TargetRegisterInfo::isPhysicalRegister(MO.getReg()) &&
  78            "Virtual registers should be already mapped!");
  79     O << getRegisterName(MO.getReg());
  80     break;
  81
  82   case MachineOperand::MO_Immediate:
  83     O << MO.getImm();
  84     break;
  85   case MachineOperand::MO_MachineBasicBlock:
  86     O << *MO.getMBB()->getSymbol();
  87     return;
  88   case MachineOperand::MO_GlobalAddress:
  89     O << *Mang->getSymbol(MO.getGlobal());
  90     printOffset(MO.getOffset(), O);
  91     break;
  92   case MachineOperand::MO_ExternalSymbol:
  93     O << *GetExternalSymbolSymbol(MO.getSymbolName());
  94     break;
  95   case MachineOperand::MO_ConstantPoolIndex:
  96     O << MAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << "_"
  97       << MO.getIndex();
  98     break;
  99   case MachineOperand::MO_JumpTableIndex:
 100     O << MAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
 101       << '_' << MO.getIndex();
 102     break;
 103   default:
 104     llvm_unreachable("<unknown operand type>");
 105     break;
 106   }
 107 }
 108
 109 void BlackfinAsmPrinter::printMemoryOperand(const MachineInstr *MI, int opNum,
 110                                             raw_ostream &O) {
 111   printOperand(MI, opNum, O);
 112
 113   if (MI->getOperand(opNum+1).isImm() && MI->getOperand(opNum+1).getImm() == 0)
 114     return;
 115
 116   O << " + ";
 117   printOperand(MI, opNum+1, O);
 118 }
 119
 120 /// PrintAsmOperand - Print out an operand for an inline asm expression.
 121 ///
 122 bool BlackfinAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
 123                                          unsigned OpNo,
 124                                          unsigned AsmVariant,
 125                                          const char *ExtraCode) {
 126   if (ExtraCode && ExtraCode[0]) {
 127     if (ExtraCode[1] != 0) return true; // Unknown modifier.
 128
 129     switch (ExtraCode[0]) {
 130     default: return true;  // Unknown modifier.
 131     case 'r':
 132       break;
 133     }
 134   }
 135
 136   printOperand(MI, OpNo, O);
 137
 138   return false;
 139 }
 140
 141 bool BlackfinAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 142                                                unsigned OpNo,
 143                                                unsigned AsmVariant,
 144                                                const char *ExtraCode) {
 145   if (ExtraCode && ExtraCode[0])
 146     return true;  // Unknown modifier
 147
 148   O << '[';
 149   printOperand(MI, OpNo, O);
 150   O << ']';
 151
 152   return false;
 153 }