49#define DEBUG_TYPE "assembler"
54STATISTIC(EmittedFragments,
"Number of emitted assembler fragments - total");
56 "Number of emitted assembler fragments - relaxable");
58 "Number of emitted assembler fragments - data");
60 "Number of emitted assembler fragments - align");
62 "Number of emitted assembler fragments - fill");
63STATISTIC(EmittedNopsFragments,
"Number of emitted assembler fragments - nops");
64STATISTIC(EmittedOrgFragments,
"Number of emitted assembler fragments - org");
65STATISTIC(evaluateFixup,
"Number of evaluated fixups");
66STATISTIC(ObjectBytes,
"Number of emitted object file bytes");
67STATISTIC(RelaxationSteps,
"Number of assembler layout and relaxation steps");
68STATISTIC(RelaxedInstructions,
"Number of relaxed instructions");
81 std::unique_ptr<MCAsmBackend> Backend,
82 std::unique_ptr<MCCodeEmitter>
Emitter,
83 std::unique_ptr<MCObjectWriter> Writer)
84 : Context(Context), Backend(
std::
move(Backend)),
104 if (Section.isRegistered())
106 assert(Section.curFragList()->Head &&
"allocInitialFragment not called");
108 Section.setIsRegistered(
true);
113 if (ThumbFuncs.count(Symbol))
116 if (!Symbol->isVariable())
119 const MCExpr *Expr = Symbol->getVariableValue();
139 ThumbFuncs.insert(Symbol);
146 ++stats::evaluateFixup;
165 "unsupported subtraction of qualified symbol");
182 bool IsResolved =
false;
186 }
else if (!
Target.getSymA()) {
196 *
this, SA, *
DF,
false,
true);
200 IsResolved =
Target.isAbsolute();
218 assert((ShouldAlignPC ? IsPCRel :
true) &&
219 "FKF_IsAlignedDownTo32Bits is only allowed on PC-relative fixups!");
226 if (ShouldAlignPC)
Offset &= ~0x3;
239 if (!IsResolved &&
Target.getSymA() &&
Target.getSymB() &&
249 switch (
F.getKind()) {
251 return cast<MCDataFragment>(
F).getContents().size();
253 return cast<MCRelaxableFragment>(
F).getContents().size();
255 auto &FF = cast<MCFillFragment>(
F);
256 int64_t NumValues = 0;
257 if (!FF.getNumValues().evaluateKnownAbsolute(NumValues, *
this)) {
259 "expected assembly-time absolute expression");
262 int64_t
Size = NumValues * FF.getValueSize();
271 return cast<MCNopsFragment>(
F).getNumBytes();
274 return cast<MCLEBFragment>(
F).getContents().size();
277 return cast<MCBoundaryAlignFragment>(
F).getSize();
309 "expected assembly-time absolute expression");
314 int64_t TargetLocation =
Value.getConstant();
321 TargetLocation += Val;
323 int64_t
Size = TargetLocation - FragmentOffset;
324 if (Size < 0 || Size >= 0x40000000) {
326 OF.
getLoc(),
"invalid .org offset '" +
Twine(TargetLocation) +
327 "' (at offset '" +
Twine(FragmentOffset) +
"')");
334 return cast<MCDwarfLineAddrFragment>(
F).getContents().size();
336 return cast<MCDwarfCallFrameFragment>(
F).getContents().size();
338 return cast<MCCVInlineLineTableFragment>(
F).getContents().size();
340 return cast<MCCVDefRangeFragment>(
F).getContents().size();
342 return cast<MCPseudoProbeAddrFragment>(
F).getContents().size();
356 uint64_t OffsetInBundle = FOffset & (BundleSize - 1);
357 uint64_t EndOfFragment = OffsetInBundle + FSize;
366 if (
F->alignToBundleEnd()) {
377 if (EndOfFragment == BundleSize)
379 else if (EndOfFragment < BundleSize)
380 return BundleSize - EndOfFragment;
382 return 2 * BundleSize - EndOfFragment;
384 }
else if (OffsetInBundle > 0 && EndOfFragment > BundleSize)
385 return BundleSize - OffsetInBundle;
412 assert(isa<MCEncodedFragment>(
F) &&
413 "Only MCEncodedFragment implementations have instructions");
422 if (RequiredBundlePadding > UINT8_MAX)
425 EF->Offset += RequiredBundlePadding;
426 if (
auto *
DF = dyn_cast_or_null<MCDataFragment>(Prev))
427 if (
DF->getContents().empty())
428 DF->Offset = EF->Offset;
515 if (!Symbol.isVariable())
518 const MCExpr *Expr = Symbol.getVariableValue();
522 "expression could not be evaluated");
531 "' could not be evaluated in a subtraction expression");
542 "Common symbol '" + ASym.
getName() +
543 "' cannot be used in assignment expr");
565 bool Changed = !Symbol.isRegistered();
567 Symbol.setIsRegistered(
true);
568 Symbols.push_back(&Symbol);
579 if (BundlePadding > 0) {
581 "Writing bundle padding with disabled bundling");
583 "Writing bundle padding for a fragment without instructions");
585 unsigned TotalLength = BundlePadding +
static_cast<unsigned>(FSize);
597 if (!
getBackend().writeNopData(
OS, DistanceToBoundary, STI))
599 Twine(DistanceToBoundary) +
" bytes");
600 BundlePadding -= DistanceToBoundary;
604 Twine(BundlePadding) +
" bytes");
612 uint64_t FragmentSize = Asm.computeFragmentSize(
F);
617 Asm.writeFragmentPadding(
OS, *EF, FragmentSize);
624 ++stats::EmittedFragments;
626 switch (
F.getKind()) {
628 ++stats::EmittedAlignFragments;
640 "' is not a divisor of padding size '" +
641 Twine(FragmentSize) +
"'");
650 Twine(Count) +
" bytes");
655 for (
uint64_t i = 0; i != Count; ++i) {
674 ++stats::EmittedDataFragments;
675 OS << cast<MCDataFragment>(
F).getContents();
679 ++stats::EmittedRelaxableFragments;
680 OS << cast<MCRelaxableFragment>(
F).getContents();
684 ++stats::EmittedFillFragments;
688 const unsigned MaxChunkSize = 16;
689 char Data[MaxChunkSize];
690 assert(0 < VSize && VSize <= MaxChunkSize &&
"Illegal fragment fill size");
693 for (
unsigned I = 0;
I != VSize; ++
I) {
695 Data[
I] = uint8_t(V >> (index * 8));
697 for (
unsigned I = VSize;
I < MaxChunkSize; ++
I)
701 const unsigned NumPerChunk = MaxChunkSize / VSize;
703 const unsigned ChunkSize = VSize * NumPerChunk;
707 for (
uint64_t I = 0, E = FragmentSize / ChunkSize;
I != E; ++
I)
711 unsigned TrailingCount = FragmentSize % ChunkSize;
718 ++stats::EmittedNopsFragments;
723 int64_t MaximumNopLength =
726 assert(NumBytes > 0 &&
"Expected positive NOPs fragment size");
727 assert(ControlledNopLength >= 0 &&
"Expected non-negative NOP size");
729 if (ControlledNopLength > MaximumNopLength) {
730 Asm.getContext().reportError(NF.
getLoc(),
731 "illegal NOP size " +
732 std::to_string(ControlledNopLength) +
733 ". (expected within [0, " +
734 std::to_string(MaximumNopLength) +
"])");
737 ControlledNopLength = MaximumNopLength;
741 if (!ControlledNopLength)
742 ControlledNopLength = MaximumNopLength;
746 (
uint64_t)std::min(NumBytes, ControlledNopLength);
747 assert(NumBytesToEmit &&
"try to emit empty NOP instruction");
748 if (!Asm.getBackend().writeNopData(
OS, NumBytesToEmit,
751 Twine(NumBytesToEmit) +
" bytes");
754 NumBytes -= NumBytesToEmit;
769 Twine(FragmentSize) +
" bytes");
780 ++stats::EmittedOrgFragments;
783 for (
uint64_t i = 0, e = FragmentSize; i != e; ++i)
800 const auto &OF = cast<MCCVInlineLineTableFragment>(
F);
801 OS << OF.getContents();
805 const auto &DRF = cast<MCCVDefRangeFragment>(
F);
806 OS << DRF.getContents();
819 "The stream should advance by fragment size");
832 switch (
F.getKind()) {
839 if (
DF.fixup_begin() !=
DF.fixup_end())
841 " section '" + Sec->getName() +
842 "' cannot have fixups");
843 for (
unsigned i = 0, e =
DF.getContents().size(); i != e; ++i)
844 if (
DF.getContents()[i]) {
846 Sec->getVirtualSectionKind() +
847 " section '" + Sec->getName() +
848 "' cannot have non-zero initializers");
856 assert((cast<MCAlignFragment>(
F).getValueSize() == 0 ||
857 cast<MCAlignFragment>(
F).getValue() == 0) &&
858 "Invalid align in virtual section!");
861 assert((cast<MCFillFragment>(
F).getValue() == 0) &&
862 "Invalid fill in virtual section!");
882std::tuple<MCValue, uint64_t, bool>
890 evaluateFixup(
Fixup, &
F,
Target, STI, FixedValue, WasForced);
897 return std::make_tuple(
Target, FixedValue, IsResolved);
903 errs() <<
"assembler backend - pre-layout\n--\n";
907 unsigned SectionIndex = 0;
912 if (Sec.Subsections.size() > 1) {
915 for (
auto &[
_,
List] : Sec.Subsections) {
920 Sec.Subsections.clear();
921 Sec.Subsections.push_back({0u, {Dummy.getNext(),
Tail}});
922 Sec.CurFragList = &Sec.Subsections[0].second;
924 unsigned FragmentIndex = 0;
926 Frag.setLayoutOrder(FragmentIndex++);
931 this->HasLayout =
true;
932 while (layoutOnce()) {
943 errs() <<
"assembler backend - post-relaxation\n--\n";
950 errs() <<
"assembler backend - final-layout\n--\n";
965 switch (Frag.getKind()) {
978 Fixups =
DF.getFixups();
979 Contents =
DF.getContents();
980 STI =
DF.getSubtargetInfo();
981 assert(!
DF.hasInstructions() || STI !=
nullptr);
1000 Fixups =
DF.getFixups();
1001 Contents =
DF.getContents();
1006 Fixups =
DF.getFixups();
1007 Contents =
DF.getContents();
1011 auto &LF = cast<MCLEBFragment>(Frag);
1012 Fixups = LF.getFixups();
1013 Contents = LF.getContents();
1027 std::tie(
Target, FixedValue, IsResolved) =
1028 handleFixup(Frag,
Fixup, STI);
1045bool MCAssembler::fixupNeedsRelaxation(
const MCFixup &
Fixup,
1051 bool Resolved = evaluateFixup(
Fixup,
DF,
Target,
DF->getSubtargetInfo(),
1066 if (!
getBackend().mayNeedRelaxation(
F->getInst(), *
F->getSubtargetInfo()))
1070 if (fixupNeedsRelaxation(
Fixup,
F))
1078 "Expected CodeEmitter defined for relaxInstruction");
1079 if (!fragmentNeedsRelaxation(&
F))
1082 ++stats::RelaxedInstructions;
1094 F.getFixups().clear();
1095 F.getContents().clear();
1097 *
F.getSubtargetInfo());
1102 const unsigned OldSize =
static_cast<unsigned>(LF.
getContents().
size());
1103 unsigned PadTo = OldSize;
1119 "leb128 expression is not absolute");
1147 Align BoundaryAlignment) {
1149 return (StartAddr >>
Log2(BoundaryAlignment)) !=
1150 ((EndAddr - 1) >>
Log2(BoundaryAlignment));
1160 Align BoundaryAlignment) {
1162 return (EndAddr & (BoundaryAlignment.
value() - 1)) == 0;
1172 Align BoundaryAlignment) {
1203 if (
getBackend().relaxDwarfLineAddr(*
this,
DF, WasRelaxed))
1209 bool Abs =
DF.getAddrDelta().evaluateKnownAbsolute(AddrDelta, *
this);
1210 assert(Abs &&
"We created a line delta with an invalid expression");
1213 LineDelta =
DF.getLineDelta();
1216 DF.getFixups().clear();
1220 return OldSize !=
Data.size();
1230 bool Abs =
DF.getAddrDelta().evaluateAsAbsolute(
Value, *
this);
1233 "invalid CFI advance_loc expression");
1241 DF.getFixups().clear();
1244 return OldSize !=
Data.size();
1248 unsigned OldSize =
F.getContents().size();
1250 return OldSize !=
F.getContents().size();
1254 unsigned OldSize =
F.getContents().size();
1256 return OldSize !=
F.getContents().size();
1263 assert(Abs &&
"We created a pseudo probe with an invalid expression");
1272 return OldSize !=
Data.size();
1276 switch(
F.getKind()) {
1281 "Did not expect a MCRelaxableFragment in RelaxAll mode");
1282 return relaxInstruction(cast<MCRelaxableFragment>(
F));
1284 return relaxDwarfLineAddr(cast<MCDwarfLineAddrFragment>(
F));
1286 return relaxDwarfCallFrameFragment(cast<MCDwarfCallFrameFragment>(
F));
1288 return relaxLEB(cast<MCLEBFragment>(
F));
1290 return relaxBoundaryAlign(cast<MCBoundaryAlignFragment>(
F));
1292 return relaxCVInlineLineTable(cast<MCCVInlineLineTableFragment>(
F));
1294 return relaxCVDefRange(cast<MCCVDefRangeFragment>(
F));
1296 return relaxPseudoProbeAddr(cast<MCPseudoProbeAddrFragment>(
F));
1300bool MCAssembler::layoutOnce() {
1301 ++stats::RelaxationSteps;
1303 bool Changed =
false;
1306 if (relaxFragment(Frag))
1311#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1315 OS <<
"<MCAssembler\n";
1316 OS <<
" Sections:[\n ";
1336 OS <<
", Index:" <<
Sym.getIndex() <<
", ";
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
dxil DXContainer Global Emitter
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
static uint64_t computeBundlePadding(unsigned BundleSize, const MCEncodedFragment *F, uint64_t FOffset, uint64_t FSize)
static bool getSymbolOffsetImpl(const MCAssembler &Asm, const MCSymbol &S, bool ReportError, uint64_t &Val)
static bool needPadding(uint64_t StartAddr, uint64_t Size, Align BoundaryAlignment)
Check if the branch needs padding.
static void writeFragment(raw_ostream &OS, const MCAssembler &Asm, const MCFragment &F)
Write the fragment F to the output file.
static bool mayCrossBoundary(uint64_t StartAddr, uint64_t Size, Align BoundaryAlignment)
Check if the branch crosses the boundary.
static bool isAgainstBoundary(uint64_t StartAddr, uint64_t Size, Align BoundaryAlignment)
Check if the branch is against the boundary.
static bool getLabelOffset(const MCAssembler &Asm, const MCSymbol &S, bool ReportError, uint64_t &Val)
PowerPC TLS Dynamic Call Fixup
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
void encodeInlineLineTable(const MCAssembler &Asm, MCCVInlineLineTableFragment &F)
Encodes the binary annotations once we have a layout.
void encodeDefRange(const MCAssembler &Asm, MCCVDefRangeFragment &F)
Align getAlignment() const
unsigned getMaxBytesToEmit() const
unsigned getValueSize() const
const MCSubtargetInfo * getSubtargetInfo() const
virtual void relaxInstruction(MCInst &Inst, const MCSubtargetInfo &STI) const
Relax the instruction in the given fragment to the next wider instruction.
virtual bool shouldInsertFixupForCodeAlign(MCAssembler &Asm, MCAlignFragment &AF)
Hook which indicates if the target requires a fixup to be generated when handling an align directive ...
virtual bool fixupNeedsRelaxationAdvanced(const MCAssembler &Asm, const MCFixup &Fixup, bool Resolved, uint64_t Value, const MCRelaxableFragment *DF, const bool WasForced) const
Target specific predicate for whether a given fixup requires the associated instruction to be relaxed...
virtual void finishLayout(MCAssembler const &Asm) const
Give backend an opportunity to finish layout after relaxation.
virtual bool evaluateTargetFixup(const MCAssembler &Asm, const MCFixup &Fixup, const MCFragment *DF, const MCValue &Target, const MCSubtargetInfo *STI, uint64_t &Value, bool &WasForced)
virtual void reset()
lifetime management
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
virtual std::pair< bool, bool > relaxLEB128(const MCAssembler &Asm, MCLEBFragment &LF, int64_t &Value) const
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...
MCContext & getContext() const
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
void ensureValid(MCSection &Sec) const
uint64_t getSectionAddressSize(const MCSection &Sec) const
void Finish()
Finish - Do final processing and write the object to the output stream.
unsigned getBundleAlignSize() const
bool isBundlingEnabled() const
void writeSectionData(raw_ostream &OS, const MCSection *Section) const
Emit the section contents to OS.
MCObjectWriter & getWriter() const
MCCodeEmitter * getEmitterPtr() const
uint64_t getFragmentOffset(const MCFragment &F) const
void layoutBundle(MCFragment *Prev, MCFragment *F) const
MCCodeEmitter & getEmitter() const
MCAssembler(MCContext &Context, std::unique_ptr< MCAsmBackend > Backend, std::unique_ptr< MCCodeEmitter > Emitter, std::unique_ptr< MCObjectWriter > Writer)
Construct a new assembler instance.
bool isThumbFunc(const MCSymbol *Func) const
Check whether a given symbol has been flagged with .thumb_func.
MCAsmBackend & getBackend() const
bool registerSection(MCSection &Section)
uint64_t computeFragmentSize(const MCFragment &F) const
Compute the effective fragment size.
const MCSymbol * getBaseSymbol(const MCSymbol &Symbol) const
MCAsmBackend * getBackendPtr() const
iterator_range< pointee_iterator< typename SmallVector< const MCSymbol *, 0 >::const_iterator > > symbols() const
uint64_t getSectionFileSize(const MCSection &Sec) const
void reset()
Reuse an assembler instance.
bool registerSymbol(const MCSymbol &Symbol)
MCDwarfLineTableParams getDWARFLinetableParams() const
void writeFragmentPadding(raw_ostream &OS, const MCEncodedFragment &F, uint64_t FSize) const
Write the necessary bundle padding to OS.
Represents required padding such that a particular other set of fragments does not cross a particular...
void setSize(uint64_t Value)
const MCFragment * getLastFragment() const
const MCSubtargetInfo * getSubtargetInfo() const
Align getAlignment() const
Fragment representing the .cv_def_range directive.
Fragment representing the binary annotations produced by the .cv_inline_linetable directive.
virtual void encodeInstruction(const MCInst &Inst, SmallVectorImpl< char > &CB, SmallVectorImpl< MCFixup > &Fixups, const MCSubtargetInfo &STI) const =0
Encode the given Inst to bytes and append to CB.
virtual void reset()
Lifetime management.
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Context object for machine code objects.
CodeViewContext & getCVContext()
void reportError(SMLoc L, const Twine &Msg)
Fragment for data and encoded instructions.
static void encodeAdvanceLoc(MCContext &Context, uint64_t AddrDelta, SmallVectorImpl< char > &OS)
static void encode(MCContext &Context, MCDwarfLineTableParams Params, int64_t LineDelta, uint64_t AddrDelta, SmallVectorImpl< char > &OS)
Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
SmallVectorImpl< MCFixup > & getFixups()
SmallVectorImpl< char > & getContents()
Interface implemented by fragments that contain encoded instructions and/or data.
const MCSubtargetInfo * getSubtargetInfo() const
Retrieve the MCSubTargetInfo in effect when the instruction was encoded.
void setBundlePadding(uint8_t N)
Set the padding size for this fragment.
uint8_t getBundlePadding() const
Get the padding size that must be inserted before this fragment.
bool alignToBundleEnd() const
Should this fragment be placed at the end of an aligned bundle?
Base class for the full range of assembler expressions which are needed for parsing.
bool evaluateAsValue(MCValue &Res, const MCAssembler &Asm) const
Try to evaluate the expression to the form (a - b + constant) where neither a nor b are variables.
bool evaluateKnownAbsolute(int64_t &Res, const MCAssembler &Asm) const
Aggressive variant of evaluateAsRelocatable when relocations are unavailable (e.g.
bool evaluateAsRelocatable(MCValue &Res, const MCAssembler *Asm, const MCFixup *Fixup) const
Try to evaluate the expression to a relocatable value, i.e.
uint8_t getValueSize() const
uint64_t getValue() const
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
MCSection * getParent() const
MCFragment * getNext() const
bool hasInstructions() const
Does this fragment have instructions emitted into it? By default this is false, but specific fragment...
Instances of this class represent a single low-level machine instruction.
const MCExpr & getValue() const
void setValue(const MCExpr *Expr)
int64_t getControlledNopLength() const
int64_t getNumBytes() const
const MCSubtargetInfo * getSubtargetInfo() const
virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm, const MCSymbol &SymA, const MCFragment &FB, bool InSet, bool IsPCRel) const
virtual void executePostLayoutBinding(MCAssembler &Asm)
Perform any late binding of symbols (for example, to assign symbol indices for use when generating re...
bool getSubsectionsViaSymbols() const
virtual uint64_t writeObject(MCAssembler &Asm)=0
Write the object file and returns the number of bytes written.
virtual void recordRelocation(MCAssembler &Asm, const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target, uint64_t &FixedValue)=0
Record a relocation entry.
const MCExpr & getOffset() const
const MCExpr & getAddrDelta() const
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Instances of this class represent a uniqued identifier for a section in the current translation unit.
void setOrdinal(unsigned Value)
bool isVirtualSection() const
Check whether this section is "virtual", that is has no actual object file contents.
virtual bool useCodeAlign() const =0
Return true if a .align directive should use "optimized nops" to fill instead of 0s.
FragList * curFragList() const
void setHasLayout(bool Value)
Generic base class for all target subtargets.
Represents a symbol table index fragment.
const MCSymbol * getSymbol()
Represent a reference to a symbol from inside an expression.
const MCSymbol & getSymbol() const
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
const MCExpr * getVariableValue(bool SetUsed=true) const
getVariableValue - Get the value for variable symbols.
bool isCommon() const
Is this a 'common' symbol.
StringRef getName() const
getName - Get the symbol name.
bool isVariable() const
isVariable - Check if this is a variable symbol.
bool isUndefined(bool SetUsed=true) const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
uint32_t getIndex() const
Get the (implementation defined) index.
uint64_t getOffset() const
MCFragment * getFragment(bool SetUsed=true) const
This represents an "assembler immediate".
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Represents a location in source code.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
StringRef - Represent a constant reference to a string, i.e.
Target - Wrapper for Target specific information.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
This class implements an extremely fast bulk output stream that can only output to a stream.
uint64_t tell() const
tell - Return the current offset with the file.
raw_ostream & write(unsigned char C)
A raw_ostream that writes to an SmallVector or SmallString.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
This is an optimization pass for GlobalISel generic memory operations.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
@ FK_Data_1
A one-byte fixup.
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Ref
The access may reference the value stored in memory.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
unsigned encodeSLEB128(int64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a SLEB128 value to an output stream.
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
unsigned Log2(Align A)
Returns the log2 of the alignment.
Implement std::hash so that hash_code can be used in STL containers.
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
@ FKF_IsTarget
Should this fixup be evaluated in a target dependent manner?
@ FKF_IsAlignedDownTo32Bits
Should this fixup kind force a 4-byte aligned effective PC value?
@ FKF_Constant
This fixup kind should be resolved if defined.
@ FKF_IsPCRel
Is this fixup kind PCrelative? This is used by the assembler backend to evaluate fixup values in a ta...
unsigned Flags
Flags describing additional information on this fixup kind.