LLVM 19.0.0git
LanaiAsmBackend.cpp
Go to the documentation of this file.
1//===-- LanaiAsmBackend.cpp - Lanai Assembler 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 "LanaiFixupKinds.h"
12#include "llvm/MC/MCAssembler.h"
20
21using namespace llvm;
22
23// Prepare value for the target space
24static unsigned adjustFixupValue(unsigned Kind, uint64_t Value) {
25 switch (Kind) {
26 case FK_Data_1:
27 case FK_Data_2:
28 case FK_Data_4:
29 case FK_Data_8:
30 return Value;
37 return Value;
38 default:
39 llvm_unreachable("Unknown fixup kind!");
40 }
41}
42
43namespace {
44class LanaiAsmBackend : public MCAsmBackend {
45 Triple::OSType OSType;
46
47public:
48 LanaiAsmBackend(const Target &T, Triple::OSType OST)
49 : MCAsmBackend(llvm::endianness::big), OSType(OST) {}
50
51 void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
53 uint64_t Value, bool IsResolved,
54 const MCSubtargetInfo *STI) const override;
55
56 std::unique_ptr<MCObjectTargetWriter>
57 createObjectTargetWriter() const override;
58
59 // No instruction requires relaxation
60 bool fixupNeedsRelaxation(const MCFixup & /*Fixup*/, uint64_t /*Value*/,
61 const MCRelaxableFragment * /*DF*/,
62 const MCAsmLayout & /*Layout*/) const override {
63 return false;
64 }
65
66 const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override;
67
68 unsigned getNumFixupKinds() const override {
70 }
71
73 const MCSubtargetInfo *STI) const override;
74};
75
76bool LanaiAsmBackend::writeNopData(raw_ostream &OS, uint64_t Count,
77 const MCSubtargetInfo *STI) const {
78 if ((Count % 4) != 0)
79 return false;
80
81 for (uint64_t i = 0; i < Count; i += 4)
82 OS.write("\x15\0\0\0", 4);
83
84 return true;
85}
86
87void LanaiAsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
88 const MCValue &Target,
90 bool /*IsResolved*/,
91 const MCSubtargetInfo * /*STI*/) const {
92 MCFixupKind Kind = Fixup.getKind();
93 Value = adjustFixupValue(static_cast<unsigned>(Kind), Value);
94
95 if (!Value)
96 return; // This value doesn't change the encoding
97
98 // Where in the object and where the number of bytes that need
99 // fixing up
100 unsigned Offset = Fixup.getOffset();
101 unsigned NumBytes = (getFixupKindInfo(Kind).TargetSize + 7) / 8;
102 unsigned FullSize = 4;
103
104 // Grab current value, if any, from bits.
105 uint64_t CurVal = 0;
106
107 // Load instruction and apply value
108 for (unsigned i = 0; i != NumBytes; ++i) {
109 unsigned Idx = (FullSize - 1 - i);
110 CurVal |= static_cast<uint64_t>(static_cast<uint8_t>(Data[Offset + Idx]))
111 << (i * 8);
112 }
113
114 uint64_t Mask =
115 (static_cast<uint64_t>(-1) >> (64 - getFixupKindInfo(Kind).TargetSize));
116 CurVal |= Value & Mask;
117
118 // Write out the fixed up bytes back to the code/data bits.
119 for (unsigned i = 0; i != NumBytes; ++i) {
120 unsigned Idx = (FullSize - 1 - i);
121 Data[Offset + Idx] = static_cast<uint8_t>((CurVal >> (i * 8)) & 0xff);
122 }
123}
124
125std::unique_ptr<MCObjectTargetWriter>
126LanaiAsmBackend::createObjectTargetWriter() const {
128}
129
130const MCFixupKindInfo &
131LanaiAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
132 static const MCFixupKindInfo Infos[Lanai::NumTargetFixupKinds] = {
133 // This table *must* be in same the order of fixup_* kinds in
134 // LanaiFixupKinds.h.
135 // Note: The number of bits indicated here are assumed to be contiguous.
136 // This does not hold true for LANAI_21 and LANAI_21_F which are applied
137 // to bits 0x7cffff and 0x7cfffc, respectively. Since the 'bits' counts
138 // here are used only for cosmetic purposes, we set the size to 16 bits
139 // for these 21-bit relocation as llvm/lib/MC/MCAsmStreamer.cpp checks
140 // no bits are set in the fixup range.
141 //
142 // name offset bits flags
143 {"FIXUP_LANAI_NONE", 0, 32, 0},
144 {"FIXUP_LANAI_21", 16, 16 /*21*/, 0},
145 {"FIXUP_LANAI_21_F", 16, 16 /*21*/, 0},
146 {"FIXUP_LANAI_25", 7, 25, 0},
147 {"FIXUP_LANAI_32", 0, 32, 0},
148 {"FIXUP_LANAI_HI16", 16, 16, 0},
149 {"FIXUP_LANAI_LO16", 16, 16, 0}};
150
151 if (Kind < FirstTargetFixupKind)
153
154 assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
155 "Invalid kind!");
156 return Infos[Kind - FirstTargetFixupKind];
157}
158
159} // namespace
160
162 const MCSubtargetInfo &STI,
163 const MCRegisterInfo & /*MRI*/,
164 const MCTargetOptions & /*Options*/) {
165 const Triple &TT = STI.getTargetTriple();
166 if (!TT.isOSBinFormatELF())
167 llvm_unreachable("OS not supported");
168
169 return new LanaiAsmBackend(T, TT.getOS());
170}
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static unsigned adjustFixupValue(unsigned Kind, uint64_t Value)
PowerPC TLS Dynamic Call Fixup
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:43
virtual bool writeNopData(raw_ostream &OS, uint64_t Count, const MCSubtargetInfo *STI) const =0
Write an (optimal) nop sequence of Count bytes to the given output.
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.
virtual std::unique_ptr< MCObjectTargetWriter > createObjectTargetWriter() const =0
virtual unsigned getNumFixupKinds() const =0
Get the number of target specific fixup kinds.
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
virtual void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target, MutableArrayRef< char > Data, uint64_t Value, bool IsResolved, const MCSubtargetInfo *STI) const =0
Apply the Value for given Fixup into the provided data fragment, at the offset specified by the fixup...
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:274
Generic base class for all target subtargets.
const Triple & getTargetTriple() const
This represents an "assembler immediate".
Definition: MCValue.h:36
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:307
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
raw_ostream & write(unsigned char C)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:121
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
MCAsmBackend * createLanaiAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:21
@ FirstTargetFixupKind
Definition: MCFixup.h:45
@ FK_Data_8
A eight-byte fixup.
Definition: MCFixup.h:26
@ FK_Data_1
A one-byte fixup.
Definition: MCFixup.h:23
@ FK_Data_4
A four-byte fixup.
Definition: MCFixup.h:25
@ FK_Data_2
A two-byte fixup.
Definition: MCFixup.h:24
std::unique_ptr< MCObjectTargetWriter > createLanaiELFObjectWriter(uint8_t OSABI)
endianness
Definition: bit.h:70
Target independent information on a fixup kind.