Home | History | Annotate | Download | only in MCTargetDesc 
      1 //===-- AMDGPUAsmBackend.cpp - AMDGPU 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 /// \file
      9 //===----------------------------------------------------------------------===//
     10 
     11 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
     12 #include "llvm/ADT/StringRef.h"
     13 #include "llvm/MC/MCAsmBackend.h"
     14 #include "llvm/MC/MCAssembler.h"
     15 #include "llvm/MC/MCObjectWriter.h"
     16 #include "llvm/MC/MCValue.h"
     17 #include "llvm/Support/TargetRegistry.h"
     18 
     19 using namespace llvm;
     20 
     21 namespace {
     22 
     23 class AMDGPUMCObjectWriter : public MCObjectWriter {
     24 public:
     25   AMDGPUMCObjectWriter(raw_ostream &OS) : MCObjectWriter(OS, true) { }
     26   virtual void ExecutePostLayoutBinding(MCAssembler &Asm,
     27                                         const MCAsmLayout &Layout) {
     28     //XXX: Implement if necessary.
     29   }
     30   virtual void RecordRelocation(const MCAssembler &Asm,
     31                                 const MCAsmLayout &Layout,
     32                                 const MCFragment *Fragment,
     33                                 const MCFixup &Fixup,
     34                                 MCValue Target, uint64_t &FixedValue) {
     35     assert(!"Not implemented");
     36   }
     37 
     38   virtual void WriteObject(MCAssembler &Asm, const MCAsmLayout &Layout);
     39 
     40 };
     41 
     42 class AMDGPUAsmBackend : public MCAsmBackend {
     43 public:
     44   AMDGPUAsmBackend(const Target &T)
     45     : MCAsmBackend() {}
     46 
     47   virtual AMDGPUMCObjectWriter *createObjectWriter(raw_ostream &OS) const;
     48   virtual unsigned getNumFixupKinds() const { return 0; };
     49   virtual void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
     50                           uint64_t Value) const;
     51   virtual bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
     52                                     const MCRelaxableFragment *DF,
     53                                     const MCAsmLayout &Layout) const {
     54     return false;
     55   }
     56   virtual void relaxInstruction(const MCInst &Inst, MCInst &Res) const {
     57     assert(!"Not implemented");
     58   }
     59   virtual bool mayNeedRelaxation(const MCInst &Inst) const { return false; }
     60   virtual bool writeNopData(uint64_t Count, MCObjectWriter *OW) const {
     61     return true;
     62   }
     63 };
     64 
     65 } //End anonymous namespace
     66 
     67 void AMDGPUMCObjectWriter::WriteObject(MCAssembler &Asm,
     68                                        const MCAsmLayout &Layout) {
     69   for (MCAssembler::iterator I = Asm.begin(), E = Asm.end(); I != E; ++I) {
     70     Asm.writeSectionData(I, Layout);
     71   }
     72 }
     73 
     74 MCAsmBackend *llvm::createAMDGPUAsmBackend(const Target &T, StringRef TT,
     75                                            StringRef CPU) {
     76   return new AMDGPUAsmBackend(T);
     77 }
     78 
     79 AMDGPUMCObjectWriter * AMDGPUAsmBackend::createObjectWriter(
     80                                                         raw_ostream &OS) const {
     81   return new AMDGPUMCObjectWriter(OS);
     82 }
     83 
     84 void AMDGPUAsmBackend::applyFixup(const MCFixup &Fixup, char *Data,
     85                                   unsigned DataSize, uint64_t Value) const {
     86 
     87   uint16_t *Dst = (uint16_t*)(Data + Fixup.getOffset());
     88   assert(Fixup.getKind() == FK_PCRel_4);
     89   *Dst = (Value - 4) / 4;
     90 }
     91