LLVM  9.0.0svn
MCAsmBackend.cpp
Go to the documentation of this file.
1 //===- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------===//
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 #include "llvm/MC/MCAsmBackend.h"
10 #include "llvm/ADT/None.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/MC/MCCodePadder.h"
16 #include "llvm/MC/MCObjectWriter.h"
19 #include <cassert>
20 #include <cstddef>
21 #include <cstdint>
22 
23 using namespace llvm;
24 
26  : CodePadder(new MCCodePadder()), Endian(Endian) {}
27 
28 MCAsmBackend::~MCAsmBackend() = default;
29 
30 std::unique_ptr<MCObjectWriter>
32  auto TW = createObjectTargetWriter();
33  switch (TW->getFormat()) {
34  case Triple::ELF:
35  return createELFObjectWriter(cast<MCELFObjectTargetWriter>(std::move(TW)), OS,
37  case Triple::MachO:
38  return createMachObjectWriter(cast<MCMachObjectTargetWriter>(std::move(TW)),
39  OS, Endian == support::little);
40  case Triple::COFF:
42  cast<MCWinCOFFObjectTargetWriter>(std::move(TW)), OS);
43  case Triple::Wasm:
44  return createWasmObjectWriter(cast<MCWasmObjectTargetWriter>(std::move(TW)),
45  OS);
46  default:
47  llvm_unreachable("unexpected object format");
48  }
49 }
50 
51 std::unique_ptr<MCObjectWriter>
53  raw_pwrite_stream &DwoOS) const {
54  auto TW = createObjectTargetWriter();
55  if (TW->getFormat() != Triple::ELF)
56  report_fatal_error("dwo only supported with ELF");
57  return createELFDwoObjectWriter(cast<MCELFObjectTargetWriter>(std::move(TW)),
58  OS, DwoOS, Endian == support::little);
59 }
60 
62  return None;
63 }
64 
66  static const MCFixupKindInfo Builtins[] = {
67  {"FK_Data_1", 0, 8, 0},
68  {"FK_Data_2", 0, 16, 0},
69  {"FK_Data_4", 0, 32, 0},
70  {"FK_Data_8", 0, 64, 0},
71  {"FK_PCRel_1", 0, 8, MCFixupKindInfo::FKF_IsPCRel},
72  {"FK_PCRel_2", 0, 16, MCFixupKindInfo::FKF_IsPCRel},
73  {"FK_PCRel_4", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
74  {"FK_PCRel_8", 0, 64, MCFixupKindInfo::FKF_IsPCRel},
75  {"FK_GPRel_1", 0, 8, 0},
76  {"FK_GPRel_2", 0, 16, 0},
77  {"FK_GPRel_4", 0, 32, 0},
78  {"FK_GPRel_8", 0, 64, 0},
79  {"FK_DTPRel_4", 0, 32, 0},
80  {"FK_DTPRel_8", 0, 64, 0},
81  {"FK_TPRel_4", 0, 32, 0},
82  {"FK_TPRel_8", 0, 64, 0},
83  {"FK_SecRel_1", 0, 8, 0},
84  {"FK_SecRel_2", 0, 16, 0},
85  {"FK_SecRel_4", 0, 32, 0},
86  {"FK_SecRel_8", 0, 64, 0},
87  {"FK_Data_Add_1", 0, 8, 0},
88  {"FK_Data_Add_2", 0, 16, 0},
89  {"FK_Data_Add_4", 0, 32, 0},
90  {"FK_Data_Add_8", 0, 64, 0},
91  {"FK_Data_Sub_1", 0, 8, 0},
92  {"FK_Data_Sub_2", 0, 16, 0},
93  {"FK_Data_Sub_4", 0, 32, 0},
94  {"FK_Data_Sub_8", 0, 64, 0}};
95 
96  assert((size_t)Kind <= array_lengthof(Builtins) && "Unknown fixup kind");
97  return Builtins[Kind];
98 }
99 
101  const MCFixup &Fixup, bool Resolved, uint64_t Value,
102  const MCRelaxableFragment *DF, const MCAsmLayout &Layout,
103  const bool WasForced) const {
104  if (!Resolved)
105  return true;
106  return fixupNeedsRelaxation(Fixup, Value, DF, Layout);
107 }
108 
111  CodePadder->handleBasicBlockStart(OS, Context);
112 }
113 
115  const MCCodePaddingContext &Context) {
116  CodePadder->handleBasicBlockEnd(Context);
117 }
118 
120  CodePadder->handleInstructionBegin(Inst);
121 }
122 
124  CodePadder->handleInstructionEnd(Inst);
125 }
126 
128  return CodePadder->relaxFragment(PF, Layout);
129 }
Fragment for adding required padding.
Definition: MCFragment.h:340
void handleCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context)
Handles all target related code padding after writing a block to an object file.
LLVMContext & Context
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
const support::endianness Endian
Definition: MCAsmBackend.h:52
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
virtual ~MCAsmBackend()
virtual std::unique_ptr< MCObjectTargetWriter > createObjectTargetWriter() const =0
void handleCodePaddingInstructionEnd(const MCInst &Inst)
Handles all target related code padding after writing an instruction to an object file...
virtual bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value, const MCRelaxableFragment *DF, const MCAsmLayout &Layout) const =0
Simple predicate for targets where !Resolved implies requiring relaxation.
Target-independent base class incharge of all code padding decisions for a target.
Definition: MCCodePadder.h:38
std::unique_ptr< MCObjectWriter > createDwoObjectWriter(raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS) const
Create an MCObjectWriter that writes two object files: a .o file which is linked into the final progr...
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:73
Is this fixup kind PCrelative? This is used by the assembler backend to evaluate fixup values in a ta...
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
virtual bool fixupNeedsRelaxationAdvanced(const MCFixup &Fixup, bool Resolved, uint64_t Value, const MCRelaxableFragment *DF, const MCAsmLayout &Layout, const bool WasForced) const
Target specific predicate for whether a given fixup requires the associated instruction to be relaxed...
Streaming object file generation interface.
std::unique_ptr< MCObjectWriter > createELFObjectWriter(std::unique_ptr< MCELFObjectTargetWriter > MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new ELF writer instance.
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:270
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:22
std::unique_ptr< MCObjectWriter > createWasmObjectWriter(std::unique_ptr< MCWasmObjectTargetWriter > MOTW, raw_pwrite_stream &OS)
Construct a new Wasm writer instance.
void handleCodePaddingInstructionBegin(const MCInst &Inst)
Handles all target related code padding before writing a new instruction to an object file...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::unique_ptr< MCObjectWriter > createWinCOFFObjectWriter(std::unique_ptr< MCWinCOFFObjectTargetWriter > MOTW, raw_pwrite_stream &OS)
Construct a new Win COFF writer instance.
PowerPC TLS Dynamic Call Fixup
void handleCodePaddingBasicBlockStart(MCObjectStreamer *OS, const MCCodePaddingContext &Context)
Handles all target related code padding when starting to write a new basic block to an object file...
std::unique_ptr< MCObjectWriter > createELFDwoObjectWriter(std::unique_ptr< MCELFObjectTargetWriter > MOTW, raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS, bool IsLittleEndian)
constexpr size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:1043
virtual Optional< MCFixupKind > getFixupKind(StringRef Name) const
Map a relocation name used in .reloc to a fixup kind.
std::unique_ptr< MCObjectWriter > createObjectWriter(raw_pwrite_stream &OS) const
Create a new MCObjectWriter instance for use by the assembler backend to emit the final object file...
std::unique_ptr< MCObjectWriter > createMachObjectWriter(std::unique_ptr< MCMachObjectTargetWriter > MOTW, raw_pwrite_stream &OS, bool IsLittleEndian)
Construct a new Mach-O writer instance.
Target independent information on a fixup kind.
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:340
bool relaxFragment(MCPaddingFragment *PF, MCAsmLayout &Layout)
Relaxes a fragment (changes the size of the padding) according to target requirements.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:72
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
MCAsmBackend(support::endianness Endian)