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