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 void SystemZAsmPrinter::EmitInstruction(const MachineInstr *MI) {
  39   SystemZMCInstLower Lower(Mang, MF->getContext(), *this);
  40   MCInst LoweredMI;
  41   switch (MI->getOpcode()) {
  42   case SystemZ::Return:
  43     LoweredMI = MCInstBuilder(SystemZ::BR).addReg(SystemZ::R14D);
  44     break;
  45
  46   case SystemZ::CallBRASL:
  47     LoweredMI = MCInstBuilder(SystemZ::BRASL)
  48       .addReg(SystemZ::R14D)
  49       .addExpr(Lower.getExpr(MI->getOperand(0), MCSymbolRefExpr::VK_PLT));
  50     break;
  51
  52   case SystemZ::CallBASR:
  53     LoweredMI = MCInstBuilder(SystemZ::BASR)
  54       .addReg(SystemZ::R14D)
  55       .addReg(MI->getOperand(0).getReg());
  56     break;
  57
  58   case SystemZ::CallJG:
  59     LoweredMI = MCInstBuilder(SystemZ::JG)
  60       .addExpr(Lower.getExpr(MI->getOperand(0), MCSymbolRefExpr::VK_PLT));
  61     break;
  62
  63   case SystemZ::CallBR:
  64     LoweredMI = MCInstBuilder(SystemZ::BR).addReg(SystemZ::R1D);
  65     break;
  66
  67   case SystemZ::IILF64:
  68     LoweredMI = MCInstBuilder(SystemZ::IILF)
  69       .addReg(SystemZMC::getRegAsGR32(MI->getOperand(0).getReg()))
  70       .addImm(MI->getOperand(2).getImm());
  71     break;
  72
  73 #define LOWER_LOW(NAME)                                                 \
  74   case SystemZ::NAME##64: LoweredMI = lowerRILow(MI, SystemZ::NAME); break
  75
  76   LOWER_LOW(IILL);
  77   LOWER_LOW(IILH);
  78   LOWER_LOW(NILL);
  79   LOWER_LOW(NILH);
  80   LOWER_LOW(NILF);
  81   LOWER_LOW(OILL);
  82   LOWER_LOW(OILH);
  83   LOWER_LOW(OILF);
  84   LOWER_LOW(XILF);
  85
  86 #undef LOWER_LOW
  87
  88   default:
  89     Lower.lower(MI, LoweredMI);
  90     break;
  91   }
  92   OutStreamer.EmitInstruction(LoweredMI);
  93 }
  94
  95 // Convert a SystemZ-specific constant pool modifier into the associated
  96 // MCSymbolRefExpr variant kind.
  97 static MCSymbolRefExpr::VariantKind
  98 getModifierVariantKind(SystemZCP::SystemZCPModifier Modifier) {
  99   switch (Modifier) {
 100   case SystemZCP::NTPOFF: return MCSymbolRefExpr::VK_NTPOFF;
 101   }
 102   llvm_unreachable("Invalid SystemCPModifier!");
 103 }
 104
 105 void SystemZAsmPrinter::
 106 EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {
 107   SystemZConstantPoolValue *ZCPV =
 108     static_cast<SystemZConstantPoolValue*>(MCPV);
 109
 110   const MCExpr *Expr =
 111     MCSymbolRefExpr::Create(Mang->getSymbol(ZCPV->getGlobalValue()),
 112                             getModifierVariantKind(ZCPV->getModifier()),
 113                             OutContext);
 114   uint64_t Size = TM.getDataLayout()->getTypeAllocSize(ZCPV->getType());
 115
 116   OutStreamer.EmitValue(Expr, Size);
 117 }
 118
 119 bool SystemZAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
 120                                         unsigned OpNo,
 121                                         unsigned AsmVariant,
 122                                         const char *ExtraCode,
 123                                         raw_ostream &OS) {
 124   if (ExtraCode && *ExtraCode == 'n') {
 125     if (!MI->getOperand(OpNo).isImm())
 126       return true;
 127     OS << -int64_t(MI->getOperand(OpNo).getImm());
 128   } else {
 129     SystemZMCInstLower Lower(Mang, MF->getContext(), *this);
 130     MCOperand MO(Lower.lowerOperand(MI->getOperand(OpNo)));
 131     SystemZInstPrinter::printOperand(MO, OS);
 132   }
 133   return false;
 134 }
 135
 136 bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
 137                                               unsigned OpNo,
 138                                               unsigned AsmVariant,
 139                                               const char *ExtraCode,
 140                                               raw_ostream &OS) {
 141   SystemZInstPrinter::printAddress(MI->getOperand(OpNo).getReg(),
 142                                    MI->getOperand(OpNo + 1).getImm(),
 143                                    MI->getOperand(OpNo + 2).getReg(), OS);
 144   return false;
 145 }
 146
 147 void SystemZAsmPrinter::EmitEndOfAsmFile(Module &M) {
 148   if (Subtarget->isTargetELF()) {
 149     const TargetLoweringObjectFileELF &TLOFELF =
 150       static_cast<const TargetLoweringObjectFileELF &>(getObjFileLowering());
 151
 152     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 153
 154     // Output stubs for external and common global variables.
 155     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
 156     if (!Stubs.empty()) {
 157       OutStreamer.SwitchSection(TLOFELF.getDataRelSection());
 158       const DataLayout *TD = TM.getDataLayout();
 159
 160       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {
 161         OutStreamer.EmitLabel(Stubs[i].first);
 162         OutStreamer.EmitSymbolValue(Stubs[i].second.getPointer(),
 163                                     TD->getPointerSize(0));
 164       }
 165       Stubs.clear();
 166     }
 167   }
 168 }
 169
 170 // Force static initialization.
 171 extern "C" void LLVMInitializeSystemZAsmPrinter() {
 172   RegisterAsmPrinter<SystemZAsmPrinter> X(TheSystemZTarget);
 173 }