Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/MC/MCELFObjectWriter.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/MC/MCELFObjectWriter.h - ELF Object Writer ----------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#ifndef LLVM_MC_MCELFOBJECTWRITER_H
10
#define LLVM_MC_MCELFOBJECTWRITER_H
11
12
#include "llvm/ADT/Triple.h"
13
#include "llvm/BinaryFormat/ELF.h"
14
#include "llvm/MC/MCObjectWriter.h"
15
#include "llvm/MC/MCSectionELF.h"
16
#include "llvm/Support/Casting.h"
17
#include "llvm/Support/raw_ostream.h"
18
#include <cstdint>
19
#include <vector>
20
21
namespace llvm {
22
23
class MCAssembler;
24
class MCContext;
25
class MCFixup;
26
class MCObjectWriter;
27
class MCSymbol;
28
class MCSymbolELF;
29
class MCValue;
30
31
struct ELFRelocationEntry {
32
  uint64_t Offset; // Where is the relocation.
33
  const MCSymbolELF *Symbol; // The symbol to relocate with.
34
  unsigned Type;   // The type of the relocation.
35
  uint64_t Addend; // The addend to use.
36
  const MCSymbolELF *OriginalSymbol; // The original value of Symbol if we changed it.
37
  uint64_t OriginalAddend; // The original value of addend.
38
39
  ELFRelocationEntry(uint64_t Offset, const MCSymbolELF *Symbol, unsigned Type,
40
                     uint64_t Addend, const MCSymbolELF *OriginalSymbol,
41
                     uint64_t OriginalAddend)
42
      : Offset(Offset), Symbol(Symbol), Type(Type), Addend(Addend),
43
26.7k
        OriginalSymbol(OriginalSymbol), OriginalAddend(OriginalAddend) {}
44
45
0
  void print(raw_ostream &Out) const {
46
0
    Out << "Off=" << Offset << ", Sym=" << Symbol << ", Type=" << Type
47
0
        << ", Addend=" << Addend << ", OriginalSymbol=" << OriginalSymbol
48
0
        << ", OriginalAddend=" << OriginalAddend;
49
0
  }
50
51
0
  void dump() const { print(errs()); }
52
};
53
54
class MCELFObjectTargetWriter : public MCObjectTargetWriter {
55
  const uint8_t OSABI;
56
  const uint8_t ABIVersion;
57
  const uint16_t EMachine;
58
  const unsigned HasRelocationAddend : 1;
59
  const unsigned Is64Bit : 1;
60
61
protected:
62
  MCELFObjectTargetWriter(bool Is64Bit_, uint8_t OSABI_, uint16_t EMachine_,
63
                          bool HasRelocationAddend_, uint8_t ABIVersion_ = 0);
64
65
public:
66
28.4k
  virtual ~MCELFObjectTargetWriter() = default;
67
68
28.6k
  virtual Triple::ObjectFormatType getFormat() const { return Triple::ELF; }
69
0
  static bool classof(const MCObjectTargetWriter *W) {
70
0
    return W->getFormat() == Triple::ELF;
71
0
  }
72
73
25.0k
  static uint8_t getOSABI(Triple::OSType OSType) {
74
25.0k
    switch (OSType) {
75
25.0k
      case Triple::CloudABI:
76
3
        return ELF::ELFOSABI_CLOUDABI;
77
25.0k
      case Triple::HermitCore:
78
0
        return ELF::ELFOSABI_STANDALONE;
79
25.0k
      case Triple::PS4:
80
195
      case Triple::FreeBSD:
81
195
        return ELF::ELFOSABI_FREEBSD;
82
24.8k
      default:
83
24.8k
        return ELF::ELFOSABI_NONE;
84
25.0k
    }
85
25.0k
  }
86
87
  virtual unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
88
                                const MCFixup &Fixup, bool IsPCRel) const = 0;
89
90
  virtual bool needsRelocateWithSymbol(const MCSymbol &Sym,
91
                                       unsigned Type) const;
92
93
  virtual void sortRelocs(const MCAssembler &Asm,
94
                          std::vector<ELFRelocationEntry> &Relocs);
95
96
  virtual void addTargetSectionFlags(MCContext &Ctx, MCSectionELF &Sec);
97
98
  /// \name Accessors
99
  /// @{
100
5.82k
  uint8_t getOSABI() const { return OSABI; }
101
5.81k
  uint8_t getABIVersion() const { return ABIVersion; }
102
40.5k
  uint16_t getEMachine() const { return EMachine; }
103
69.7k
  bool hasRelocationAddend() const { return HasRelocationAddend; }
104
3.12M
  bool is64Bit() const { return Is64Bit; }
105
  /// @}
106
107
  // Instead of changing everyone's API we pack the N64 Type fields
108
  // into the existing 32 bit data unsigned.
109
10.4k
#define R_TYPE_SHIFT 0
110
75
#define R_TYPE_MASK 0xffffff00
111
11.6k
#define R_TYPE2_SHIFT 8
112
75
#define R_TYPE2_MASK 0xffff00ff
113
11.6k
#define R_TYPE3_SHIFT 16
114
75
#define R_TYPE3_MASK 0xff00ffff
115
10.3k
#define R_SSYM_SHIFT 24
116
#define R_SSYM_MASK 0x00ffffff
117
118
  // N64 relocation type accessors
119
10.3k
  uint8_t getRType(uint32_t Type) const {
120
10.3k
    return (unsigned)((Type >> R_TYPE_SHIFT) & 0xff);
121
10.3k
  }
122
11.5k
  uint8_t getRType2(uint32_t Type) const {
123
11.5k
    return (unsigned)((Type >> R_TYPE2_SHIFT) & 0xff);
124
11.5k
  }
125
11.5k
  uint8_t getRType3(uint32_t Type) const {
126
11.5k
    return (unsigned)((Type >> R_TYPE3_SHIFT) & 0xff);
127
11.5k
  }
128
10.3k
  uint8_t getRSsym(uint32_t Type) const {
129
10.3k
    return (unsigned)((Type >> R_SSYM_SHIFT) & 0xff);
130
10.3k
  }
131
132
  // N64 relocation type setting
133
75
  unsigned setRType(unsigned Value, unsigned Type) const {
134
75
    return ((Type & R_TYPE_MASK) | ((Value & 0xff) << R_TYPE_SHIFT));
135
75
  }
136
75
  unsigned setRType2(unsigned Value, unsigned Type) const {
137
75
    return (Type & R_TYPE2_MASK) | ((Value & 0xff) << R_TYPE2_SHIFT);
138
75
  }
139
75
  unsigned setRType3(unsigned Value, unsigned Type) const {
140
75
    return (Type & R_TYPE3_MASK) | ((Value & 0xff) << R_TYPE3_SHIFT);
141
75
  }
142
0
  unsigned setRSsym(unsigned Value, unsigned Type) const {
143
0
    return (Type & R_SSYM_MASK) | ((Value & 0xff) << R_SSYM_SHIFT);
144
0
  }
145
};
146
147
/// Construct a new ELF writer instance.
148
///
149
/// \param MOTW - The target specific ELF writer subclass.
150
/// \param OS - The stream to write to.
151
/// \returns The constructed object writer.
152
std::unique_ptr<MCObjectWriter>
153
createELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
154
                      raw_pwrite_stream &OS, bool IsLittleEndian);
155
156
std::unique_ptr<MCObjectWriter>
157
createELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW,
158
                         raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS,
159
                         bool IsLittleEndian);
160
161
} // end namespace llvm
162
163
#endif // LLVM_MC_MCELFOBJECTWRITER_H