LCOV - code coverage report
Current view: top level - lib/Target/AMDGPU/MCTargetDesc - AMDGPUELFObjectWriter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 23 24 95.8 %
Date: 2018-02-23 15:42:53 Functions: 3 4 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- AMDGPUELFObjectWriter.cpp - AMDGPU ELF Writer ----------------------===//
       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 "AMDGPUMCTargetDesc.h"
      11             : #include "llvm/BinaryFormat/ELF.h"
      12             : #include "llvm/MC/MCELFObjectWriter.h"
      13             : #include "llvm/MC/MCExpr.h"
      14             : #include "llvm/MC/MCFixup.h"
      15             : #include "llvm/MC/MCObjectWriter.h"
      16             : #include "llvm/MC/MCSymbol.h"
      17             : #include "llvm/MC/MCValue.h"
      18             : #include "llvm/Support/ErrorHandling.h"
      19             : 
      20             : using namespace llvm;
      21             : 
      22             : namespace {
      23             : 
      24         132 : class AMDGPUELFObjectWriter : public MCELFObjectTargetWriter {
      25             : public:
      26             :   AMDGPUELFObjectWriter(bool Is64Bit, uint8_t OSABI, bool HasRelocationAddend);
      27             : 
      28             : protected:
      29             :   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
      30             :                         const MCFixup &Fixup, bool IsPCRel) const override;
      31             : };
      32             : 
      33             : 
      34             : } // end anonymous namespace
      35             : 
      36             : AMDGPUELFObjectWriter::AMDGPUELFObjectWriter(bool Is64Bit,
      37             :                                              uint8_t OSABI,
      38         132 :                                              bool HasRelocationAddend)
      39             :   : MCELFObjectTargetWriter(Is64Bit, OSABI, ELF::EM_AMDGPU,
      40         132 :                             HasRelocationAddend) {}
      41             : 
      42         197 : unsigned AMDGPUELFObjectWriter::getRelocType(MCContext &Ctx,
      43             :                                              const MCValue &Target,
      44             :                                              const MCFixup &Fixup,
      45             :                                              bool IsPCRel) const {
      46         197 :   if (const auto *SymA = Target.getSymA()) {
      47             :     // SCRATCH_RSRC_DWORD[01] is a special global variable that represents
      48             :     // the scratch buffer.
      49         197 :     if (SymA->getSymbol().getName() == "SCRATCH_RSRC_DWORD0")
      50             :       return ELF::R_AMDGPU_ABS32_LO;
      51             : 
      52             :     if (SymA->getSymbol().getName() == "SCRATCH_RSRC_DWORD1")
      53             :       return ELF::R_AMDGPU_ABS32_HI;
      54             :   }
      55             : 
      56         195 :   switch (Target.getAccessVariant()) {
      57             :   default:
      58             :     break;
      59             :   case MCSymbolRefExpr::VK_GOTPCREL:
      60             :     return ELF::R_AMDGPU_GOTPCREL;
      61          10 :   case MCSymbolRefExpr::VK_AMDGPU_GOTPCREL32_LO:
      62          10 :     return ELF::R_AMDGPU_GOTPCREL32_LO;
      63          10 :   case MCSymbolRefExpr::VK_AMDGPU_GOTPCREL32_HI:
      64          10 :     return ELF::R_AMDGPU_GOTPCREL32_HI;
      65           4 :   case MCSymbolRefExpr::VK_AMDGPU_REL32_LO:
      66           4 :     return ELF::R_AMDGPU_REL32_LO;
      67           4 :   case MCSymbolRefExpr::VK_AMDGPU_REL32_HI:
      68           4 :     return ELF::R_AMDGPU_REL32_HI;
      69             :   }
      70             : 
      71         161 :   switch (Fixup.getKind()) {
      72             :   default: break;
      73             :   case FK_PCRel_4:
      74             :     return ELF::R_AMDGPU_REL32;
      75         109 :   case FK_Data_4:
      76             :   case FK_SecRel_4:
      77         109 :     return ELF::R_AMDGPU_ABS32;
      78          49 :   case FK_Data_8:
      79          49 :     return ELF::R_AMDGPU_ABS64;
      80             :   }
      81             : 
      82           0 :   llvm_unreachable("unhandled relocation type");
      83             : }
      84             : 
      85             : std::unique_ptr<MCObjectWriter>
      86         132 : llvm::createAMDGPUELFObjectWriter(bool Is64Bit, uint8_t OSABI,
      87             :                                   bool HasRelocationAddend,
      88             :                                   raw_pwrite_stream &OS) {
      89             :   auto MOTW = llvm::make_unique<AMDGPUELFObjectWriter>(Is64Bit, OSABI,
      90         132 :                                                        HasRelocationAddend);
      91         396 :   return createELFObjectWriter(std::move(MOTW), OS, true);
      92             : }

Generated by: LCOV version 1.13