Home | History | Annotate | Download | only in MCTargetDesc
      1 //===-- MBlazeAsmBackend.cpp - MBlaze Assembler Backend -------------------===//
      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 #include "MCTargetDesc/MBlazeMCTargetDesc.h"
     11 #include "llvm/ADT/Twine.h"
     12 #include "llvm/MC/MCAsmBackend.h"
     13 #include "llvm/MC/MCAsmLayout.h"
     14 #include "llvm/MC/MCAssembler.h"
     15 #include "llvm/MC/MCELFObjectWriter.h"
     16 #include "llvm/MC/MCELFSymbolFlags.h"
     17 #include "llvm/MC/MCExpr.h"
     18 #include "llvm/MC/MCObjectWriter.h"
     19 #include "llvm/MC/MCSectionELF.h"
     20 #include "llvm/MC/MCSectionMachO.h"
     21 #include "llvm/MC/MCValue.h"
     22 #include "llvm/Support/ELF.h"
     23 #include "llvm/Support/ErrorHandling.h"
     24 #include "llvm/Support/TargetRegistry.h"
     25 #include "llvm/Support/raw_ostream.h"
     26 using namespace llvm;
     27 
     28 static unsigned getFixupKindSize(unsigned Kind) {
     29   switch (Kind) {
     30   default: llvm_unreachable("invalid fixup kind!");
     31   case FK_Data_1: return 1;
     32   case FK_PCRel_2:
     33   case FK_Data_2: return 2;
     34   case FK_PCRel_4:
     35   case FK_Data_4: return 4;
     36   case FK_Data_8: return 8;
     37   }
     38 }
     39 
     40 
     41 namespace {
     42 
     43 class MBlazeAsmBackend : public MCAsmBackend {
     44 public:
     45   MBlazeAsmBackend(const Target &T)
     46     : MCAsmBackend() {
     47   }
     48 
     49   unsigned getNumFixupKinds() const {
     50     return 2;
     51   }
     52 
     53   bool mayNeedRelaxation(const MCInst &Inst) const;
     54 
     55   bool fixupNeedsRelaxation(const MCFixup &Fixup,
     56                             uint64_t Value,
     57                             const MCRelaxableFragment *DF,
     58                             const MCAsmLayout &Layout) const;
     59 
     60   void relaxInstruction(const MCInst &Inst, MCInst &Res) const;
     61 
     62   bool writeNopData(uint64_t Count, MCObjectWriter *OW) const;
     63 
     64   unsigned getPointerSize() const {
     65     return 4;
     66   }
     67 };
     68 
     69 static unsigned getRelaxedOpcode(unsigned Op) {
     70     switch (Op) {
     71     default:            return Op;
     72     case MBlaze::ADDIK: return MBlaze::ADDIK32;
     73     case MBlaze::ORI:   return MBlaze::ORI32;
     74     case MBlaze::BRLID: return MBlaze::BRLID32;
     75     }
     76 }
     77 
     78 bool MBlazeAsmBackend::mayNeedRelaxation(const MCInst &Inst) const {
     79   if (getRelaxedOpcode(Inst.getOpcode()) == Inst.getOpcode())
     80     return false;
     81 
     82   bool hasExprOrImm = false;
     83   for (unsigned i = 0; i < Inst.getNumOperands(); ++i)
     84     hasExprOrImm |= Inst.getOperand(i).isExpr();
     85 
     86   return hasExprOrImm;
     87 }
     88 
     89 bool MBlazeAsmBackend::fixupNeedsRelaxation(const MCFixup &Fixup,
     90                                             uint64_t Value,
     91                                             const MCRelaxableFragment *DF,
     92                                             const MCAsmLayout &Layout) const {
     93   // FIXME: Is this right? It's what the "generic" code was doing before,
     94   // but is X86 specific. Is it actually true for MBlaze also, or was it
     95   // just close enough to not be a big deal?
     96   //
     97   // Relax if the value is too big for a (signed) i8.
     98   return int64_t(Value) != int64_t(int8_t(Value));
     99 }
    100 
    101 void MBlazeAsmBackend::relaxInstruction(const MCInst &Inst, MCInst &Res) const {
    102   Res = Inst;
    103   Res.setOpcode(getRelaxedOpcode(Inst.getOpcode()));
    104 }
    105 
    106 bool MBlazeAsmBackend::writeNopData(uint64_t Count, MCObjectWriter *OW) const {
    107   if ((Count % 4) != 0)
    108     return false;
    109 
    110   for (uint64_t i = 0; i < Count; i += 4)
    111       OW->Write32(0x00000000);
    112 
    113   return true;
    114 }
    115 } // end anonymous namespace
    116 
    117 namespace {
    118 class ELFMBlazeAsmBackend : public MBlazeAsmBackend {
    119 public:
    120   uint8_t OSABI;
    121   ELFMBlazeAsmBackend(const Target &T, uint8_t _OSABI)
    122     : MBlazeAsmBackend(T), OSABI(_OSABI) { }
    123 
    124   void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
    125                   uint64_t Value) const;
    126 
    127   MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
    128     return createMBlazeELFObjectWriter(OS, OSABI);
    129   }
    130 };
    131 
    132 void ELFMBlazeAsmBackend::applyFixup(const MCFixup &Fixup, char *Data,
    133                                      unsigned DataSize, uint64_t Value) const {
    134   unsigned Size = getFixupKindSize(Fixup.getKind());
    135 
    136   assert(Fixup.getOffset() + Size <= DataSize &&
    137          "Invalid fixup offset!");
    138 
    139   char *data = Data + Fixup.getOffset();
    140   switch (Size) {
    141   default: llvm_unreachable("Cannot fixup unknown value.");
    142   case 1:  llvm_unreachable("Cannot fixup 1 byte value.");
    143   case 8:  llvm_unreachable("Cannot fixup 8 byte value.");
    144 
    145   case 4:
    146     *(data+7) = uint8_t(Value);
    147     *(data+6) = uint8_t(Value >> 8);
    148     *(data+3) = uint8_t(Value >> 16);
    149     *(data+2) = uint8_t(Value >> 24);
    150     break;
    151 
    152   case 2:
    153     *(data+3) = uint8_t(Value >> 0);
    154     *(data+2) = uint8_t(Value >> 8);
    155   }
    156 }
    157 } // end anonymous namespace
    158 
    159 MCAsmBackend *llvm::createMBlazeAsmBackend(const Target &T, StringRef TT,
    160                                            StringRef CPU) {
    161   Triple TheTriple(TT);
    162 
    163   if (TheTriple.isOSDarwin())
    164     assert(0 && "Mac not supported on MBlaze");
    165 
    166   if (TheTriple.isOSWindows())
    167     assert(0 && "Windows not supported on MBlaze");
    168 
    169   uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TheTriple.getOS());
    170   return new ELFMBlazeAsmBackend(T, OSABI);
    171 }
    172