lib/Target/Hexagon/HexagonAsmPrinter.h

   1 //===-- HexagonAsmPrinter.h - Print machine code to an Hexagon .s file ----===//
   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 // Hexagon Assembly printer class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef HEXAGONASMPRINTER_H
  15 #define HEXAGONASMPRINTER_H
  16
  17 #include "Hexagon.h"
  18 #include "HexagonTargetMachine.h"
  19 #include "llvm/CodeGen/AsmPrinter.h"
  20 #include "llvm/Support/Compiler.h"
  21 #include "llvm/Support/raw_ostream.h"
  22
  23 namespace llvm {
  24   class HexagonAsmPrinter : public AsmPrinter {
  25     const HexagonSubtarget *Subtarget;
  26
  27   public:
  28     explicit HexagonAsmPrinter(TargetMachine &TM, MCStreamer &Streamer)
  29       : AsmPrinter(TM, Streamer) {
  30       Subtarget = &TM.getSubtarget<HexagonSubtarget>();
  31     }
  32
  33     virtual const char *getPassName() const {
  34       return "Hexagon Assembly Printer";
  35     }
  36
  37     bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const;
  38
  39     virtual void EmitInstruction(const MachineInstr *MI);
  40     virtual void EmitAlignment(unsigned NumBits,
  41                                const GlobalValue *GV = 0) const;
  42
  43     void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
  44     bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
  45                          unsigned AsmVariant, const char *ExtraCode,
  46                          raw_ostream &OS);
  47     bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
  48                                unsigned AsmVariant, const char *ExtraCode,
  49                                raw_ostream &OS);
  50
  51     //    void printMachineInstruction(const MachineInstr *MI);
  52     void printOp(const MachineOperand &MO, raw_ostream &O);
  53
  54     /// printRegister - Print register according to target requirements.
  55     ///
  56     void printRegister(const MachineOperand &MO, bool R0AsZero,
  57                        raw_ostream &O) {
  58       unsigned RegNo = MO.getReg();
  59       assert(TargetRegisterInfo::isPhysicalRegister(RegNo) && "Not physreg??");
  60       O << getRegisterName(RegNo);
  61     }
  62
  63     void printImmOperand(const MachineInstr *MI, unsigned OpNo,
  64                                 raw_ostream &O) {
  65       int value = MI->getOperand(OpNo).getImm();
  66       O << value;
  67     }
  68
  69     void printNegImmOperand(const MachineInstr *MI, unsigned OpNo,
  70                                    raw_ostream &O) {
  71       int value = MI->getOperand(OpNo).getImm();
  72       O << -value;
  73     }
  74
  75     void printMEMriOperand(const MachineInstr *MI, unsigned OpNo,
  76                                   raw_ostream &O) {
  77       const MachineOperand &MO1 = MI->getOperand(OpNo);
  78       const MachineOperand &MO2 = MI->getOperand(OpNo+1);
  79
  80       O << getRegisterName(MO1.getReg())
  81         << " + #"
  82         << (int) MO2.getImm();
  83     }
  84
  85     void printFrameIndexOperand(const MachineInstr *MI, unsigned OpNo,
  86                                        raw_ostream &O) {
  87       const MachineOperand &MO1 = MI->getOperand(OpNo);
  88       const MachineOperand &MO2 = MI->getOperand(OpNo+1);
  89
  90       O << getRegisterName(MO1.getReg())
  91         << ", #"
  92         << MO2.getImm();
  93     }
  94
  95     void printBranchOperand(const MachineInstr *MI, unsigned OpNo,
  96                             raw_ostream &O) {
  97       // Branches can take an immediate operand.  This is used by the branch
  98       // selection pass to print $+8, an eight byte displacement from the PC.
  99       if (MI->getOperand(OpNo).isImm()) {
 100         O << "$+" << MI->getOperand(OpNo).getImm()*4;
 101       } else {
 102         printOp(MI->getOperand(OpNo), O);
 103       }
 104     }
 105
 106     void printCallOperand(const MachineInstr *MI, unsigned OpNo,
 107                           raw_ostream &O) {
 108     }
 109
 110     void printAbsAddrOperand(const MachineInstr *MI, unsigned OpNo,
 111                              raw_ostream &O) {
 112     }
 113
 114     void printSymbolHi(const MachineInstr *MI, unsigned OpNo, raw_ostream &O) {
 115       O << "#HI(";
 116       if (MI->getOperand(OpNo).isImm()) {
 117         printImmOperand(MI, OpNo, O);
 118       }
 119       else {
 120         printOp(MI->getOperand(OpNo), O);
 121       }
 122       O << ")";
 123     }
 124
 125     void printSymbolLo(const MachineInstr *MI, unsigned OpNo, raw_ostream &O) {
 126       O << "#HI(";
 127       if (MI->getOperand(OpNo).isImm()) {
 128         printImmOperand(MI, OpNo, O);
 129       }
 130       else {
 131         printOp(MI->getOperand(OpNo), O);
 132       }
 133       O << ")";
 134     }
 135
 136     void printPredicateOperand(const MachineInstr *MI, unsigned OpNo,
 137                                raw_ostream &O);
 138
 139 #if 0
 140     void printModuleLevelGV(const GlobalVariable* GVar, raw_ostream &O);
 141 #endif
 142
 143     void printAddrModeBasePlusOffset(const MachineInstr *MI, int OpNo,
 144                                      raw_ostream &O);
 145
 146     void printGlobalOperand(const MachineInstr *MI, int OpNo, raw_ostream &O);
 147     void printJumpTable(const MachineInstr *MI, int OpNo, raw_ostream &O);
 148     void printConstantPool(const MachineInstr *MI, int OpNo, raw_ostream &O);
 149
 150     static const char *getRegisterName(unsigned RegNo);
 151
 152 #if 0
 153     void EmitStartOfAsmFile(Module &M);
 154 #endif
 155   };
 156
 157 } // end of llvm namespace
 158
 159 #endif