lib/Target/SystemZ/SystemZAsmPrinter.cpp

   1 //===-- SystemZAsmPrinter.cpp - SystemZ LLVM assembly printer -------------===//
   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 // Streams SystemZ assembly language and associated data, in the form of
  11 // MCInsts and MCExprs respectively.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "SystemZAsmPrinter.h"
  16 #include "InstPrinter/SystemZInstPrinter.h"
  17 #include "SystemZConstantPoolValue.h"
  18 #include "SystemZMCInstLower.h"
  19 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
  20 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
  21 #include "llvm/MC/MCExpr.h"
  22 #include "llvm/MC/MCInstBuilder.h"
  23 #include "llvm/MC/MCStreamer.h"
  24 #include "llvm/Support/TargetRegistry.h"
  25 #include "llvm/Target/Mangler.h"
  26
  27 using namespace llvm;
  28
  29 // Return an RI instruction like MI with opcode Opcode, but with the
  30 // GR64 register operands turned into GR32s.
  31 static MCInst lowerRILow(const MachineInstr *MI, unsigned Opcode) {
  32   return MCInstBuilder(Opcode)
  33     .addReg(SystemZMC::getRegAsGR32(MI->getOperand(0).getReg()))
  34     .addReg(SystemZMC::getRegAsGR32(MI->getOperand(1).getReg()))
  35     .addImm(MI->getOperand(2).getImm());
  36 }
  37
  38 // Return an RI instruction like MI with opcode Opcode, but with the
  39 // R2 register turned into a GR64.
  40 static MCInst lowerRIEfLow(const MachineInstr *MI, unsigned Opcode) {
  41   return MCInstBuilder(Opcode)
  42     .addReg(MI->getOperand(0).getReg())
  43     .addReg(MI->getOperand(1).getReg())
  44     .addReg(SystemZMC::getRegAsGR64(MI->getOperand(2).getReg()))
  45     .addImm(MI->getOperand(3).getImm())
  46     .addImm(MI->getOperand(4).getImm())
  47     .addImm(MI->getOperand(5).getImm());
  48 }
  49
  50 void SystemZAsmPrinter::EmitInstruction(const MachineInstr *MI) {
  51   SystemZMCInstLower Lower(Mang, MF->getContext(), *this);
  52   MCInst LoweredMI;
  53   switch (MI->getOpcode()) {
  54   case SystemZ::Return:
  55     LoweredMI = MCInstBuilder(SystemZ::BR).addReg(SystemZ::R14D);
  56     break;
  57
  58   case SystemZ::CallBRASL:
  59     LoweredMI = MCInstBuilder(SystemZ::BRASL)
  60       .addReg(SystemZ::R14D)
  61       .addExpr(Lower.getExpr(MI->getOperand(0), MCSymbolRefExpr::VK_PLT));
  62     break;
  63
  64   case SystemZ::CallBASR:
  65     LoweredMI = MCInstBuilder(SystemZ::BASR)
  66       .addReg(SystemZ::R14D)
  67       .addReg(MI->getOperand(0).getReg());
  68     break;
  69
  70   case SystemZ::CallJG:
  71     LoweredMI = MCInstBuilder(SystemZ::JG)
  72       .addExpr(Lower.getExpr(MI->getOperand(0), MCSymbolRefExpr::VK_PLT));
  73     break;
  74
  75   case SystemZ::CallBR:
  76     LoweredMI = MCInstBuilder(SystemZ::BR).addReg(SystemZ::R1D);
  77     break;
  78
  79   case SystemZ::IILF64:
  80     LoweredMI = MCInstBuilder(SystemZ::IILF)
  81       .addReg(SystemZMC::getRegAsGR32(MI->getOperand(0).getReg()))
  82       .addImm(MI->getOperand(2).getImm());
  83     break;
  84
  85   case SystemZ::RISBHH:
  86   case SystemZ::RISBHL:
  87     LoweredMI = lowerRIEfLow(MI, SystemZ::RISBHG);
  88     break;
  89
  90   case SystemZ::RISBLH:
  91   case SystemZ::RISBLL:
  92     LoweredMI = lowerRIEfLow(MI, SystemZ::RISBLG);
  93     break;
  94
  95 #define LOWER_LOW(NAME)                                                 \
  96   case SystemZ::NAME##64: LoweredMI = lowerRILow(MI, SystemZ::NAME); break
  97
  98   LOWER_LOW(IILL);
  99   LOWER_LOW(IILH);
 100   LOWER_LOW(NILL);
 101   LOWER_LOW(NILH);
 102   LOWER_LOW(NILF);
 103   LOWER_LOW(OILL);
 104   LOWER_LOW(OILH);
 105   LOWER_LOW(OILF);
 106   LOWER_LOW(XILF);
 107
 108 #undef LOWER_LOW
 109
 110   default:
 111     Lower.lower(MI, LoweredMI);
 112     break;
 113   }
 114   OutStreamer.EmitInstruction(LoweredMI);
 115 }
 116
 117 // Convert a SystemZ-specific constant pool modifier into the associated
 118 // MCSymbolRefExpr variant kind.
 119 static MCSymbolRefExpr::VariantKind
 120 getModifierVariantKind(SystemZCP::SystemZCPModifier Modifier) {
 121   switch (Modifier) {
 122   case SystemZCP::NTPOFF: return MCSymbolRefExpr::VK_NTPOFF;
 123   }
 124   llvm_unreachable("Invalid SystemCPModifier!");
 125 }
 126
 127 void SystemZAsmPrinter::
 128 EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {
 129   SystemZConstantPoolValue *ZCPV =
 130     static_cast<SystemZConstantPoolValue*>(MCPV);
 131
 132   const MCExpr *Expr =
 133     MCSymbolRefExpr::Create(Mang->getSymbol(ZCPV->getGlobalValue()),
 134                             getModifierVariantKind(ZCPV->getModifier()),
 135                             OutContext);
 136   uint64_t Size = TM.getDataLayout()->getTypeAllocSize(ZCPV->getType());
 137
 138   OutStreamer.EmitValue(Expr, Size);
 139 }
 140
 141 bool SystemZAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
 142                                         unsigned OpNo,
 143                                         unsigned AsmVariant,
 144                                         const char *ExtraCode,
 145                                         raw_ostream &OS) {
 146   if (ExtraCode && *ExtraCode == 'n') {
 147     if (!MI->getOperand(OpNo).isImm())
 148       return true;
 149     OS << -int64_t(MI->getOperand(OpNo).getImm());
 150   } else {
 151     SystemZMCInstLower Lower(Mang, MF->getContext(), *this);
 152     MCOperand MO(Lower.lowerOperand(MI->getOperand(OpNo)));
 153     SystemZInstPrinter::printOperand(MO, OS);
 154   }
 155   return false;
 156 }
 157
 158 bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 159                                               unsigned OpNo,
 160                                               unsigned AsmVariant,
 161                                               const char *ExtraCode,
 162                                               raw_ostream &OS) {
 163   SystemZInstPrinter::printAddress(MI->getOperand(OpNo).getReg(),
 164                                    MI->getOperand(OpNo + 1).getImm(),
 165                                    MI->getOperand(OpNo + 2).getReg(), OS);
 166   return false;
 167 }
 168
 169 void SystemZAsmPrinter::EmitEndOfAsmFile(Module &M) {
 170   if (Subtarget->isTargetELF()) {
 171     const TargetLoweringObjectFileELF &TLOFELF =
 172       static_cast<const TargetLoweringObjectFileELF &>(getObjFileLowering());
 173
 174     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 175
 176     // Output stubs for external and common global variables.
 177     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 178     if (!Stubs.empty()) {
 179       OutStreamer.SwitchSection(TLOFELF.getDataRelSection());
 180       const DataLayout *TD = TM.getDataLayout();
 181
 182       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 183         OutStreamer.EmitLabel(Stubs[i].first);
 184         OutStreamer.EmitSymbolValue(Stubs[i].second.getPointer(),
 185                                     TD->getPointerSize(0));
 186       }
 187       Stubs.clear();
 188     }
 189   }
 190 }
 191
 192 // Force static initialization.
 193 extern "C" void LLVMInitializeSystemZAsmPrinter() {
 194   RegisterAsmPrinter<SystemZAsmPrinter> X(TheSystemZTarget);
 195 }