Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/llvm/MC/ConstantPools.h b/linux-x64/clang/include/llvm/MC/ConstantPools.h
index 2fe5ce2..9fe0cce 100644
--- a/linux-x64/clang/include/llvm/MC/ConstantPools.h
+++ b/linux-x64/clang/include/llvm/MC/ConstantPools.h
@@ -13,7 +13,6 @@
#ifndef LLVM_MC_CONSTANTPOOLS_H
#define LLVM_MC_CONSTANTPOOLS_H
-#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/SMLoc.h"
diff --git a/linux-x64/clang/include/llvm/MC/LaneBitmask.h b/linux-x64/clang/include/llvm/MC/LaneBitmask.h
index d5f6928..a467407 100644
--- a/linux-x64/clang/include/llvm/MC/LaneBitmask.h
+++ b/linux-x64/clang/include/llvm/MC/LaneBitmask.h
@@ -38,9 +38,9 @@
struct LaneBitmask {
// When changing the underlying type, change the format string as well.
- using Type = unsigned;
+ using Type = uint64_t;
enum : unsigned { BitWidth = 8*sizeof(Type) };
- constexpr static const char *const FormatStr = "%08X";
+ constexpr static const char *const FormatStr = "%016llX";
constexpr LaneBitmask() = default;
explicit constexpr LaneBitmask(Type V) : Mask(V) {}
@@ -76,7 +76,7 @@
return countPopulation(Mask);
}
unsigned getHighestLane() const {
- return Log2_32(Mask);
+ return Log2_64(Mask);
}
static constexpr LaneBitmask getNone() { return LaneBitmask(0); }
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmBackend.h b/linux-x64/clang/include/llvm/MC/MCAsmBackend.h
index 1f3ad6c..94ed3d2 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmBackend.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmBackend.h
@@ -11,36 +11,29 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCFixup.h"
#include "llvm/MC/MCFragment.h"
#include "llvm/Support/Endian.h"
#include <cstdint>
-#include <memory>
namespace llvm {
class MCAsmLayout;
class MCAssembler;
class MCCFIInstruction;
-class MCCodePadder;
struct MCFixupKindInfo;
-class MCFragment;
class MCInst;
class MCObjectStreamer;
class MCObjectTargetWriter;
class MCObjectWriter;
-struct MCCodePaddingContext;
-class MCRelaxableFragment;
class MCSubtargetInfo;
class MCValue;
class raw_pwrite_stream;
+class StringRef;
/// Generic interface to target specific assembler backends.
class MCAsmBackend {
- std::unique_ptr<MCCodePadder> CodePadder;
-
protected: // Can only create subclasses.
MCAsmBackend(support::endianness Endian);
@@ -51,6 +44,20 @@
const support::endianness Endian;
+ /// Return true if this target might automatically pad instructions and thus
+ /// need to emit padding enable/disable directives around sensative code.
+ virtual bool allowAutoPadding() const { return false; }
+ /// Return true if this target allows an unrelaxable instruction to be
+ /// emitted into RelaxableFragment and then we can increase its size in a
+ /// tricky way for optimization.
+ virtual bool allowEnhancedRelaxation() const { return false; }
+
+ /// Give the target a chance to manipulate state related to instruction
+ /// alignment (e.g. padding for optimization), instruction relaxablility, etc.
+ /// before and after actually emitting the instruction.
+ virtual void emitInstructionBegin(MCObjectStreamer &OS, const MCInst &Inst) {}
+ virtual void emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) {}
+
/// lifetime management
virtual void reset() {}
@@ -103,6 +110,14 @@
return false;
}
+ virtual bool evaluateTargetFixup(const MCAssembler &Asm,
+ const MCAsmLayout &Layout,
+ const MCFixup &Fixup, const MCFragment *DF,
+ const MCValue &Target, uint64_t &Value,
+ bool &WasForced) {
+ llvm_unreachable("Need to implement hook if target has custom fixups");
+ }
+
/// Apply the \p Value for given \p Fixup into the provided data fragment, at
/// the offset specified by the fixup and following the fixup kind as
/// appropriate. Errors (such as an out of range fixup value) should be
@@ -129,7 +144,9 @@
/// \param STI - The MCSubtargetInfo in effect when the instruction was
/// encoded.
virtual bool mayNeedRelaxation(const MCInst &Inst,
- const MCSubtargetInfo &STI) const = 0;
+ const MCSubtargetInfo &STI) const {
+ return false;
+ }
/// Target specific predicate for whether a given fixup requires the
/// associated instruction to be relaxed.
@@ -146,12 +163,11 @@
/// Relax the instruction in the given fragment to the next wider instruction.
///
- /// \param Inst The instruction to relax, which may be the same as the
- /// output.
+ /// \param [out] Inst The instruction to relax, which is also the relaxed
+ /// instruction.
/// \param STI the subtarget information for the associated instruction.
- /// \param [out] Res On return, the relaxed instruction.
- virtual void relaxInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
- MCInst &Res) const = 0;
+ virtual void relaxInstruction(MCInst &Inst,
+ const MCSubtargetInfo &STI) const {};
/// @}
@@ -161,6 +177,10 @@
///
virtual unsigned getMinimumNopSize() const { return 1; }
+ /// Returns the maximum size of a nop in bytes on this target.
+ ///
+ virtual unsigned getMaximumNopSize() const { return 0; }
+
/// Write an (optimal) nop sequence of Count bytes to the given output. If the
/// target cannot generate such a sequence, it should return an error.
///
@@ -184,40 +204,6 @@
virtual bool isMicroMips(const MCSymbol *Sym) const {
return false;
}
-
- /// Handles all target related code padding when starting to write a new
- /// basic block to an object file.
- ///
- /// \param OS The streamer used for writing the padding data and function.
- /// \param Context the context of the padding, Embeds the basic block's
- /// parameters.
- void handleCodePaddingBasicBlockStart(MCObjectStreamer *OS,
- const MCCodePaddingContext &Context);
- /// Handles all target related code padding after writing a block to an object
- /// file.
- ///
- /// \param Context the context of the padding, Embeds the basic block's
- /// parameters.
- void handleCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context);
- /// Handles all target related code padding before writing a new instruction
- /// to an object file.
- ///
- /// \param Inst the instruction.
- void handleCodePaddingInstructionBegin(const MCInst &Inst);
- /// Handles all target related code padding after writing an instruction to an
- /// object file.
- ///
- /// \param Inst the instruction.
- void handleCodePaddingInstructionEnd(const MCInst &Inst);
-
- /// Relaxes a fragment (changes the size of the padding) according to target
- /// requirements. The new size computation is done w.r.t a layout.
- ///
- /// \param PF The fragment to relax.
- /// \param Layout Code layout information.
- ///
- /// \returns true iff any relaxation occurred.
- bool relaxFragment(MCPaddingFragment *PF, MCAsmLayout &Layout);
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmInfo.h b/linux-x64/clang/include/llvm/MC/MCAsmInfo.h
index 971e935..98e9c2f 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmInfo.h
@@ -54,6 +54,15 @@
/// This class is intended to be used as a base class for asm
/// properties and features specific to the target.
class MCAsmInfo {
+public:
+ /// Assembly character literal syntax types.
+ enum AsmCharLiteralSyntax {
+ ACLS_Unknown, /// Unknown; character literals not used by LLVM for this
+ /// target.
+ ACLS_SingleQuotePrefix, /// The desired character is prefixed by a single
+ /// quote, e.g., `'A`.
+ };
+
protected:
//===------------------------------------------------------------------===//
// Properties to be set by the target writer, used to configure asm printer.
@@ -93,6 +102,10 @@
/// constants into comdat sections.
bool HasCOFFComdatConstants = false;
+ /// True if this is an XCOFF target that supports visibility attributes as
+ /// part of .global, .weak, .extern, and .comm. Default is false.
+ bool HasVisibilityOnlyWithLinkage = false;
+
/// This is the maximum possible length of an instruction, which is needed to
/// compute the size of an inline asm. Defaults to 4.
unsigned MaxInstLength = 4;
@@ -156,6 +169,10 @@
/// Defaults to false.
bool AllowAtInName = false;
+ /// This is true if the assembler allows $ @ ? characters at the start of
+ /// symbol names. Defaults to false.
+ bool AllowSymbolAtNameStart = false;
+
/// If this is true, symbol names with invalid characters will be printed in
/// quotes.
bool SupportsQuotedNames = true;
@@ -165,14 +182,26 @@
/// instead.
bool UseDataRegionDirectives = false;
+ /// True if .align is to be used for alignment. Only power-of-two
+ /// alignment is supported.
+ bool UseDotAlignForAlignment = false;
+
+ /// True if the target supports LEB128 directives.
+ bool HasLEB128Directives = true;
+
//===--- Data Emission Directives -------------------------------------===//
- /// This should be set to the directive used to get some number of zero bytes
- /// emitted to the current section. Common cases are "\t.zero\t" and
- /// "\t.space\t". If this is set to null, the Data*bitsDirective's will be
- /// used to emit zero bytes. Defaults to "\t.zero\t"
+ /// This should be set to the directive used to get some number of zero (and
+ /// non-zero if supported by the directive) bytes emitted to the current
+ /// section. Common cases are "\t.zero\t" and "\t.space\t". Defaults to
+ /// "\t.zero\t"
const char *ZeroDirective;
+ /// This should be set to true if the zero directive supports a value to emit
+ /// other than zero. If this is set to false, the Data*bitsDirective's will be
+ /// used to emit these bytes. Defaults to true.
+ bool ZeroDirectiveSupportsNonZeroValue = true;
+
/// This directive allows emission of an ascii string with the standard C
/// escape characters embedded into it. If a target doesn't support this, it
/// can be set to null. Defaults to "\t.ascii\t"
@@ -183,6 +212,16 @@
/// doesn't support this, it can be set to null. Defaults to "\t.asciz\t"
const char *AscizDirective;
+ /// This directive accepts a comma-separated list of bytes for emission as a
+ /// string of bytes. For targets that do not support this, it shall be set to
+ /// null. Defaults to null.
+ const char *ByteListDirective = nullptr;
+
+ /// Form used for character literals in the assembly syntax. Useful for
+ /// producing strings as byte lists. If a target does not use or support
+ /// this, it shall be set to ACLS_Unknown. Defaults to ACLS_Unknown.
+ AsmCharLiteralSyntax CharacterLiteralSyntax = ACLS_Unknown;
+
/// These directives are used to output some unit of integer data to the
/// current section. If a data directive is set to null, smaller data
/// directives will be used to emit the large sizes. Defaults to "\t.byte\t",
@@ -192,6 +231,9 @@
const char *Data32bitsDirective;
const char *Data64bitsDirective;
+ /// True if data directives support signed values
+ bool SupportsSignedData = true;
+
/// If non-null, a directive that is used to emit a word which should be
/// relocated as a 64-bit GP-relative offset, e.g. .gpdword on Mips. Defaults
/// to nullptr.
@@ -309,9 +351,10 @@
/// symbol that can be hidden (unexported). Defaults to false.
bool HasWeakDefCanBeHiddenDirective = false;
- /// True if we have a .linkonce directive. This is used on cygwin/mingw.
+ /// True if we should mark symbols as global instead of weak, for
+ /// weak*/linkonce*, if the symbol has a comdat.
/// Defaults to false.
- bool HasLinkOnceDirective = false;
+ bool AvoidWeakIfComdat = false;
/// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
/// hidden visibility. Defaults to MCSA_Hidden.
@@ -388,6 +431,9 @@
// %hi(), and similar unary operators.
bool HasMipsExpressions = false;
+ // If true, emit function descriptor symbol on AIX.
+ bool NeedsFunctionDescriptors = false;
+
public:
explicit MCAsmInfo();
virtual ~MCAsmInfo();
@@ -415,6 +461,7 @@
const char *getData16bitsDirective() const { return Data16bitsDirective; }
const char *getData32bitsDirective() const { return Data32bitsDirective; }
const char *getData64bitsDirective() const { return Data64bitsDirective; }
+ bool supportsSignedData() const { return SupportsSignedData; }
const char *getGPRel64Directive() const { return GPRel64Directive; }
const char *getGPRel32Directive() const { return GPRel32Directive; }
const char *getDTPRel64Directive() const { return DTPRel64Directive; }
@@ -443,6 +490,9 @@
unsigned Encoding,
MCStreamer &Streamer) const;
+ /// Return true if C is an acceptable character inside a symbol name.
+ virtual bool isAcceptableChar(char C) const;
+
/// Return true if the identifier \p Name does not need quotes to be
/// syntactically correct.
virtual bool isValidUnquotedName(StringRef Name) const;
@@ -474,6 +524,9 @@
bool hasMachoTBSSDirective() const { return HasMachoTBSSDirective; }
bool hasCOFFAssociativeComdats() const { return HasCOFFAssociativeComdats; }
bool hasCOFFComdatConstants() const { return HasCOFFComdatConstants; }
+ bool hasVisibilityOnlyWithLinkage() const {
+ return HasVisibilityOnlyWithLinkage;
+ }
/// Returns the maximum possible encoded instruction size in bytes. If \p STI
/// is null, this should be the maximum size for any subtarget.
@@ -514,15 +567,29 @@
const char *getCode64Directive() const { return Code64Directive; }
unsigned getAssemblerDialect() const { return AssemblerDialect; }
bool doesAllowAtInName() const { return AllowAtInName; }
+ bool doesAllowSymbolAtNameStart() const { return AllowSymbolAtNameStart; }
bool supportsNameQuoting() const { return SupportsQuotedNames; }
bool doesSupportDataRegionDirectives() const {
return UseDataRegionDirectives;
}
+ bool useDotAlignForAlignment() const {
+ return UseDotAlignForAlignment;
+ }
+
+ bool hasLEB128Directives() const { return HasLEB128Directives; }
+
const char *getZeroDirective() const { return ZeroDirective; }
+ bool doesZeroDirectiveSupportNonZeroValue() const {
+ return ZeroDirectiveSupportsNonZeroValue;
+ }
const char *getAsciiDirective() const { return AsciiDirective; }
const char *getAscizDirective() const { return AscizDirective; }
+ const char *getByteListDirective() const { return ByteListDirective; }
+ AsmCharLiteralSyntax characterLiteralSyntax() const {
+ return CharacterLiteralSyntax;
+ }
bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; }
unsigned getTextAlignFillValue() const { return TextAlignFillValue; }
const char *getGlobalDirective() const { return GlobalDirective; }
@@ -555,7 +622,7 @@
return HasWeakDefCanBeHiddenDirective;
}
- bool hasLinkOnceDirective() const { return HasLinkOnceDirective; }
+ bool avoidWeakIfComdat() const { return AvoidWeakIfComdat; }
MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; }
@@ -569,10 +636,6 @@
bool doesSupportDebugInformation() const { return SupportsDebugInformation; }
- bool doesSupportExceptionHandling() const {
- return ExceptionsType != ExceptionHandling::None;
- }
-
ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; }
WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; }
@@ -639,6 +702,7 @@
bool canRelaxRelocations() const { return RelaxELFRelocations; }
void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; }
bool hasMipsExpressions() const { return HasMipsExpressions; }
+ bool needsFunctionDescriptors() const { return NeedsFunctionDescriptors; }
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h b/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h
index aa2e587..408d4df 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmInfoELF.h
@@ -18,10 +18,6 @@
MCSection *getNonexecutableStackSection(MCContext &Ctx) const final;
protected:
- /// Targets which have non-executable stacks by default can set this to false
- /// to disable the special section which requests a non-executable stack.
- bool UsesNonexecutableStackSection = true;
-
MCAsmInfoELF();
};
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h b/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h
index 2a72ba7..5483899 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmInfoXCOFF.h
@@ -18,6 +18,11 @@
protected:
MCAsmInfoXCOFF();
+
+public:
+ // Return true only when C is an acceptable character inside a
+ // MCSymbolXCOFF.
+ bool isAcceptableChar(char C) const override;
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmLayout.h b/linux-x64/clang/include/llvm/MC/MCAsmLayout.h
index 45ac96f..f95af21 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmLayout.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmLayout.h
@@ -49,6 +49,10 @@
/// Get the assembler object this is a layout for.
MCAssembler &getAssembler() const { return Assembler; }
+ /// \returns whether the offset of fragment \p F can be obtained via
+ /// getFragmentOffset.
+ bool canGetFragmentOffset(const MCFragment *F) const;
+
/// Invalidate the fragments starting with F because it has been
/// resized. The fragment's size should have already been updated, but
/// its bundle padding will be recomputed.
diff --git a/linux-x64/clang/include/llvm/MC/MCAsmMacro.h b/linux-x64/clang/include/llvm/MC/MCAsmMacro.h
index 364d3b5..e3d6a85 100644
--- a/linux-x64/clang/include/llvm/MC/MCAsmMacro.h
+++ b/linux-x64/clang/include/llvm/MC/MCAsmMacro.h
@@ -124,7 +124,6 @@
}
void dump(raw_ostream &OS) const;
- void dump() const { dump(dbgs()); }
};
struct MCAsmMacroParameter {
@@ -133,10 +132,10 @@
bool Required = false;
bool Vararg = false;
- MCAsmMacroParameter() = default;
-
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void dump() const { dump(dbgs()); }
- void dump(raw_ostream &OS) const;
+ LLVM_DUMP_METHOD void dump(raw_ostream &OS) const;
+#endif
};
typedef std::vector<MCAsmMacroParameter> MCAsmMacroParameters;
@@ -144,13 +143,21 @@
StringRef Name;
StringRef Body;
MCAsmMacroParameters Parameters;
+ std::vector<std::string> Locals;
+ bool IsFunction = false;
public:
MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P)
: Name(N), Body(B), Parameters(std::move(P)) {}
+ MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P,
+ std::vector<std::string> L, bool F)
+ : Name(N), Body(B), Parameters(std::move(P)), Locals(std::move(L)),
+ IsFunction(F) {}
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void dump() const { dump(dbgs()); }
- void dump(raw_ostream &OS) const;
+ LLVM_DUMP_METHOD void dump(raw_ostream &OS) const;
+#endif
};
} // namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCAssembler.h b/linux-x64/clang/include/llvm/MC/MCAssembler.h
index 4543018..1b76559 100644
--- a/linux-x64/clang/include/llvm/MC/MCAssembler.h
+++ b/linux-x64/clang/include/llvm/MC/MCAssembler.h
@@ -190,18 +190,19 @@
/// if any offsets were adjusted.
bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec);
+ /// Perform relaxation on a single fragment - returns true if the fragment
+ /// changes as a result of relaxation.
+ bool relaxFragment(MCAsmLayout &Layout, MCFragment &F);
bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF);
-
- bool relaxPaddingFragment(MCAsmLayout &Layout, MCPaddingFragment &PF);
-
bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF);
-
+ bool relaxBoundaryAlign(MCAsmLayout &Layout, MCBoundaryAlignFragment &BF);
bool relaxDwarfLineAddr(MCAsmLayout &Layout, MCDwarfLineAddrFragment &DF);
bool relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
MCDwarfCallFrameFragment &DF);
bool relaxCVInlineLineTable(MCAsmLayout &Layout,
MCCVInlineLineTableFragment &DF);
bool relaxCVDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &DF);
+ bool relaxPseudoProbeAddr(MCAsmLayout &Layout, MCPseudoProbeAddrFragment &DF);
/// finishLayout - Finalize a layout, including fragment lowering.
void finishLayout(MCAsmLayout &Layout);
@@ -210,7 +211,12 @@
handleFixup(const MCAsmLayout &Layout, MCFragment &F, const MCFixup &Fixup);
public:
- std::vector<std::pair<StringRef, const MCSymbol *>> Symvers;
+ struct Symver {
+ StringRef Name;
+ const MCSymbol *Sym;
+ SMLoc Loc;
+ };
+ std::vector<Symver> Symvers;
/// Construct a new assembler instance.
//
@@ -443,7 +449,7 @@
void addFileName(StringRef FileName) {
if (!is_contained(FileNames, FileName))
- FileNames.push_back(FileName);
+ FileNames.push_back(std::string(FileName));
}
/// Write the necessary bundle padding to \p OS.
diff --git a/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h b/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h
index 04b4367..2794acc 100644
--- a/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h
+++ b/linux-x64/clang/include/llvm/MC/MCCodeEmitter.h
@@ -30,6 +30,12 @@
/// Lifetime management
virtual void reset() {}
+ /// Emit the prefixes of given instruction on the output stream.
+ ///
+ /// \param Inst a single low-level machine instruction.
+ /// \param OS output stream.
+ virtual void emitPrefix(const MCInst &Inst, raw_ostream &OS,
+ const MCSubtargetInfo &STI) const {}
/// EncodeInstruction - Encode the given \p Inst to bytes on the output
/// stream \p OS.
virtual void encodeInstruction(const MCInst &Inst, raw_ostream &OS,
diff --git a/linux-x64/clang/include/llvm/MC/MCCodePadder.h b/linux-x64/clang/include/llvm/MC/MCCodePadder.h
deleted file mode 100644
index f7b1a21..0000000
--- a/linux-x64/clang/include/llvm/MC/MCCodePadder.h
+++ /dev/null
@@ -1,241 +0,0 @@
-//===- llvm/MC/MCCodePadder.h - MC Code Padder ------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCCODEPADDER_H
-#define LLVM_MC_MCCODEPADDER_H
-
-#include "MCFragment.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
-
-namespace llvm {
-
-class MCAsmLayout;
-class MCCodePaddingPolicy;
-class MCFragment;
-class MCInst;
-class MCObjectStreamer;
-class MCSection;
-
-typedef SmallVector<const MCPaddingFragment *, 8> MCPFRange;
-
-struct MCCodePaddingContext {
- bool IsPaddingActive;
- bool IsBasicBlockReachableViaFallthrough;
- bool IsBasicBlockReachableViaBranch;
-};
-
-/// Target-independent base class incharge of all code padding decisions for a
-/// target. During encoding it determines if and where MCPaddingFragments will
-/// be located, as later on, when layout information is available, it determines
-/// their sizes.
-class MCCodePadder {
- MCCodePadder(const MCCodePadder &) = delete;
- void operator=(const MCCodePadder &) = delete;
-
- /// Determines if the MCCodePaddingPolicies are active.
- bool ArePoliciesActive;
-
- /// All the supported MCCodePaddingPolicies.
- SmallPtrSet<MCCodePaddingPolicy *, 4> CodePaddingPolicies;
-
- /// A pointer to the fragment of the instruction whose padding is currently
- /// done for.
- MCPaddingFragment *CurrHandledInstFragment;
-
- /// A map holding the jurisdiction for each padding fragment. Key: padding
- /// fragment. Value: The fragment's jurisdiction. A jurisdiction is a vector
- /// of padding fragments whose conditions are being controlled by another
- /// fragment, the key fragment.
- DenseMap<MCPaddingFragment *, MCPFRange> FragmentToJurisdiction;
- MCPFRange &getJurisdiction(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
-
- /// A map holding the maximal instruction window size relevant for a padding
- /// fragment.
- DenseMap<MCPaddingFragment *, uint64_t> FragmentToMaxWindowSize;
- uint64_t getMaxWindowSize(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
-
-protected:
- /// The current streamer, used to stream code padding.
- MCObjectStreamer *OS;
-
- bool addPolicy(MCCodePaddingPolicy *Policy);
-
- virtual bool
- basicBlockRequiresInsertionPoint(const MCCodePaddingContext &Context) {
- return false;
- }
-
- virtual bool instructionRequiresInsertionPoint(const MCInst &Inst) {
- return false;
- }
-
- virtual bool usePoliciesForBasicBlock(const MCCodePaddingContext &Context) {
- return Context.IsPaddingActive;
- }
-
-public:
- MCCodePadder()
- : ArePoliciesActive(false), CurrHandledInstFragment(nullptr),
- OS(nullptr) {}
- virtual ~MCCodePadder();
-
- /// Handles all target related code padding when starting to write a new
- /// basic block to an object file.
- ///
- /// \param OS The streamer used for writing the padding data and function.
- /// \param Context the context of the padding, Embeds the basic block's
- /// parameters.
- void handleBasicBlockStart(MCObjectStreamer *OS,
- const MCCodePaddingContext &Context);
- /// Handles all target related code padding when done writing a block to an
- /// object file.
- ///
- /// \param Context the context of the padding, Embeds the basic block's
- /// parameters.
- void handleBasicBlockEnd(const MCCodePaddingContext &Context);
- /// Handles all target related code padding before writing a new instruction
- /// to an object file.
- ///
- /// \param Inst the instruction.
- void handleInstructionBegin(const MCInst &Inst);
- /// Handles all target related code padding after writing an instruction to an
- /// object file.
- ///
- /// \param Inst the instruction.
- void handleInstructionEnd(const MCInst &Inst);
-
- /// Relaxes a fragment (changes the size of the padding) according to target
- /// requirements. The new size computation is done w.r.t a layout.
- ///
- /// \param Fragment The fragment to relax.
- /// \param Layout Code layout information.
- ///
- /// \returns true iff any relaxation occurred.
- bool relaxFragment(MCPaddingFragment *Fragment, MCAsmLayout &Layout);
-};
-
-/// The base class for all padding policies, i.e. a rule or set of rules to pad
-/// the generated code.
-class MCCodePaddingPolicy {
- MCCodePaddingPolicy() = delete;
- MCCodePaddingPolicy(const MCCodePaddingPolicy &) = delete;
- void operator=(const MCCodePaddingPolicy &) = delete;
-
-protected:
- /// A mask holding the kind of this policy, i.e. only the i'th bit will be set
- /// where i is the kind number.
- const uint64_t KindMask;
- /// Instruction window size relevant to this policy.
- const uint64_t WindowSize;
- /// A boolean indicating which byte of the instruction determies its
- /// instruction window. If true - the last byte of the instructions, o.w. -
- /// the first byte of the instruction.
- const bool InstByteIsLastByte;
-
- MCCodePaddingPolicy(uint64_t Kind, uint64_t WindowSize,
- bool InstByteIsLastByte)
- : KindMask(UINT64_C(1) << Kind), WindowSize(WindowSize),
- InstByteIsLastByte(InstByteIsLastByte) {}
-
- /// Computes and returns the offset of the consecutive fragment of a given
- /// fragment.
- ///
- /// \param Fragment The fragment whose consecutive offset will be computed.
- /// \param Layout Code layout information.
- ///
- /// \returns the offset of the consecutive fragment of \p Fragment.
- static uint64_t getNextFragmentOffset(const MCFragment *Fragment,
- const MCAsmLayout &Layout);
- /// Returns the instruction byte of an instruction pointed by a given
- /// MCPaddingFragment. An instruction byte is the address of the byte of an
- /// instruction which determines its instruction window.
- ///
- /// \param Fragment The fragment pointing to the instruction.
- /// \param Layout Code layout information.
- ///
- /// \returns the instruction byte of an instruction pointed by \p Fragment.
- uint64_t getFragmentInstByte(const MCPaddingFragment *Fragment,
- MCAsmLayout &Layout) const;
- uint64_t computeWindowEndAddress(const MCPaddingFragment *Fragment,
- uint64_t Offset, MCAsmLayout &Layout) const;
-
- /// Computes and returns the penalty weight of a first instruction window in a
- /// range. This requires a special function since the first window does not
- /// contain all the padding fragments in that window. It only contains all the
- /// padding fragments starting from the relevant insertion point.
- ///
- /// \param Window The first window.
- /// \param Offset The offset of the parent section relative to the beginning
- /// of the file, mod the window size.
- /// \param Layout Code layout information.
- ///
- /// \returns the penalty weight of a first instruction window in a range, \p
- /// Window.
- double computeFirstWindowPenaltyWeight(const MCPFRange &Window,
- uint64_t Offset,
- MCAsmLayout &Layout) const;
- /// Computes and returns the penalty caused by an instruction window.
- ///
- /// \param Window The instruction window.
- /// \param Offset The offset of the parent section relative to the beginning
- /// of the file, mod the window size.
- /// \param Layout Code layout information.
- ///
- /// \returns the penalty caused by \p Window.
- virtual double computeWindowPenaltyWeight(const MCPFRange &Window,
- uint64_t Offset,
- MCAsmLayout &Layout) const = 0;
-
-public:
- virtual ~MCCodePaddingPolicy() {}
-
- /// Returns the kind mask of this policy - A mask holding the kind of this
- /// policy, i.e. only the i'th bit will be set where i is the kind number.
- uint64_t getKindMask() const { return KindMask; }
- /// Returns the instruction window size relevant to this policy.
- uint64_t getWindowSize() const { return WindowSize; }
- /// Returns true if the last byte of an instruction determines its instruction
- /// window, or false if the first of an instruction determines it.
- bool isInstByteLastByte() const { return InstByteIsLastByte; }
-
- /// Returns true iff this policy needs padding for a given basic block.
- ///
- /// \param Context the context of the padding, Embeds the basic block's
- /// parameters.
- ///
- /// \returns true iff this policy needs padding for the basic block.
- virtual bool
- basicBlockRequiresPaddingFragment(const MCCodePaddingContext &Context) const {
- return false;
- }
- /// Returns true iff this policy needs padding for a given instruction.
- ///
- /// \param Inst The given instruction.
- ///
- /// \returns true iff this policy needs padding for \p Inst.
- virtual bool instructionRequiresPaddingFragment(const MCInst &Inst) const {
- return false;
- }
- /// Computes and returns the penalty caused by a range of instruction windows.
- /// The weight is computed for each window separelty and then accumulated.
- ///
- /// \param Range The range.
- /// \param Offset The offset of the parent section relative to the beginning
- /// of the file, mod the window size.
- /// \param Layout Code layout information.
- ///
- /// \returns the penalty caused by \p Range.
- double computeRangePenaltyWeight(const MCPFRange &Range, uint64_t Offset,
- MCAsmLayout &Layout) const;
-};
-
-} // namespace llvm
-
-#endif // LLVM_MC_MCCODEPADDER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCCodeView.h b/linux-x64/clang/include/llvm/MC/MCCodeView.h
index 2126354..5770f37 100644
--- a/linux-x64/clang/include/llvm/MC/MCCodeView.h
+++ b/linux-x64/clang/include/llvm/MC/MCCodeView.h
@@ -166,8 +166,6 @@
unsigned FileNo, unsigned Line, unsigned Column,
bool PrologueEnd, bool IsStmt);
- bool isValidCVFileNumber(unsigned FileNumber);
-
/// Add a line entry.
void addLineEntry(const MCCVLoc &LineEntry);
diff --git a/linux-x64/clang/include/llvm/MC/MCContext.h b/linux-x64/clang/include/llvm/MC/MCContext.h
index c40cd7c..49ab0ce 100644
--- a/linux-x64/clang/include/llvm/MC/MCContext.h
+++ b/linux-x64/clang/include/llvm/MC/MCContext.h
@@ -18,10 +18,13 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/BinaryFormat/ELF.h"
#include "llvm/BinaryFormat/XCOFF.h"
#include "llvm/MC/MCAsmMacro.h"
#include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCPseudoProbe.h"
#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptions.h"
#include "llvm/MC/SectionKind.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Compiler.h"
@@ -55,6 +58,7 @@
class MCSymbol;
class MCSymbolELF;
class MCSymbolWasm;
+ class MCSymbolXCOFF;
class SMLoc;
class SourceMgr;
@@ -94,6 +98,7 @@
SpecificBumpPtrAllocator<MCSectionMachO> MachOAllocator;
SpecificBumpPtrAllocator<MCSectionWasm> WasmAllocator;
SpecificBumpPtrAllocator<MCSectionXCOFF> XCOFFAllocator;
+ SpecificBumpPtrAllocator<MCInst> MCInstAllocator;
/// Bindings of names to symbols.
SymbolTable Symbols;
@@ -183,30 +188,42 @@
/// The maximum version of dwarf that we should emit.
uint16_t DwarfVersion = 4;
+ /// The format of dwarf that we emit.
+ dwarf::DwarfFormat DwarfFormat = dwarf::DWARF32;
+
/// Honor temporary labels, this is useful for debugging semantic
/// differences between temporary and non-temporary labels (primarily on
/// Darwin).
bool AllowTemporaryLabels = true;
- bool UseNamesOnTempLabels = true;
+ bool UseNamesOnTempLabels = false;
/// The Compile Unit ID that we are currently processing.
unsigned DwarfCompileUnitID = 0;
+ /// A collection of MCPseudoProbe in the current module
+ MCPseudoProbeTable PseudoProbeTable;
+
+ // Sections are differentiated by the quadruple (section_name, group_name,
+ // unique_id, link_to_symbol_name). Sections sharing the same quadruple are
+ // combined into one section.
struct ELFSectionKey {
std::string SectionName;
StringRef GroupName;
+ StringRef LinkedToName;
unsigned UniqueID;
ELFSectionKey(StringRef SectionName, StringRef GroupName,
- unsigned UniqueID)
- : SectionName(SectionName), GroupName(GroupName), UniqueID(UniqueID) {
- }
+ StringRef LinkedToName, unsigned UniqueID)
+ : SectionName(SectionName), GroupName(GroupName),
+ LinkedToName(LinkedToName), UniqueID(UniqueID) {}
bool operator<(const ELFSectionKey &Other) const {
if (SectionName != Other.SectionName)
return SectionName < Other.SectionName;
if (GroupName != Other.GroupName)
return GroupName < Other.GroupName;
+ if (int O = LinkedToName.compare(Other.LinkedToName))
+ return O < 0;
return UniqueID < Other.UniqueID;
}
};
@@ -278,6 +295,8 @@
/// Do automatic reset in destructor
bool AutoReset;
+ MCTargetOptions const *TargetOptions;
+
bool HadError = false;
MCSymbol *createSymbolImpl(const StringMapEntry<bool> *Name,
@@ -293,15 +312,51 @@
unsigned EntrySize,
const MCSymbolELF *Group,
unsigned UniqueID,
- const MCSymbolELF *Associated);
+ const MCSymbolELF *LinkedToSym);
+
+ MCSymbolXCOFF *createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
+ bool IsTemporary);
/// Map of currently defined macros.
StringMap<MCAsmMacro> MacroMap;
+ struct ELFEntrySizeKey {
+ std::string SectionName;
+ unsigned Flags;
+ unsigned EntrySize;
+
+ ELFEntrySizeKey(StringRef SectionName, unsigned Flags, unsigned EntrySize)
+ : SectionName(SectionName), Flags(Flags), EntrySize(EntrySize) {}
+
+ bool operator<(const ELFEntrySizeKey &Other) const {
+ if (SectionName != Other.SectionName)
+ return SectionName < Other.SectionName;
+ if ((Flags & ELF::SHF_STRINGS) != (Other.Flags & ELF::SHF_STRINGS))
+ return Other.Flags & ELF::SHF_STRINGS;
+ return EntrySize < Other.EntrySize;
+ }
+ };
+
+ // Symbols must be assigned to a section with a compatible entry
+ // size. This map is used to assign unique IDs to sections to
+ // distinguish between sections with identical names but incompatible entry
+ // sizes. This can occur when a symbol is explicitly assigned to a
+ // section, e.g. via __attribute__((section("myname"))).
+ std::map<ELFEntrySizeKey, unsigned> ELFEntrySizeMap;
+
+ // This set is used to record the generic mergeable section names seen.
+ // These are sections that are created as mergeable e.g. .debug_str. We need
+ // to avoid assigning non-mergeable symbols to these sections. It is used
+ // to prevent non-mergeable symbols being explicitly assigned to mergeable
+ // sections (e.g. via _attribute_((section("myname")))).
+ DenseSet<StringRef> ELFSeenGenericMergeableSections;
+
public:
explicit MCContext(const MCAsmInfo *MAI, const MCRegisterInfo *MRI,
const MCObjectFileInfo *MOFI,
- const SourceMgr *Mgr = nullptr, bool DoAutoReset = true);
+ const SourceMgr *Mgr = nullptr,
+ MCTargetOptions const *TargetOpts = nullptr,
+ bool DoAutoReset = true);
MCContext(const MCContext &) = delete;
MCContext &operator=(const MCContext &) = delete;
~MCContext();
@@ -330,6 +385,11 @@
/// @}
+ /// \name McInst Management
+
+ /// Create and return a new MC instruction.
+ MCInst *createMCInst();
+
/// \name Symbol Management
/// @{
@@ -337,12 +397,16 @@
/// unspecified name.
MCSymbol *createLinkerPrivateTempSymbol();
- /// Create and return a new assembler temporary symbol with a unique but
- /// unspecified name.
- MCSymbol *createTempSymbol(bool CanBeUnnamed = true);
+ /// Create a temporary symbol with a unique name. The name will be omitted
+ /// in the symbol table if UseNamesOnTempLabels is false (default except
+ /// MCAsmStreamer). The overload without Name uses an unspecified name.
+ MCSymbol *createTempSymbol();
+ MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix = true);
- MCSymbol *createTempSymbol(const Twine &Name, bool AlwaysAddSuffix,
- bool CanBeUnnamed = true);
+ /// Create a temporary symbol with a unique name whose name cannot be
+ /// omitted in the symbol table. This is rarely used.
+ MCSymbol *createNamedTempSymbol();
+ MCSymbol *createNamedTempSymbol(const Twine &Name);
/// Create the definition of a directional local symbol for numbered label
/// (used for "1:" definitions).
@@ -424,25 +488,19 @@
MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
unsigned Flags, unsigned EntrySize,
const Twine &Group) {
- return getELFSection(Section, Type, Flags, EntrySize, Group, ~0);
- }
-
- MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
- unsigned Flags, unsigned EntrySize,
- const Twine &Group, unsigned UniqueID) {
- return getELFSection(Section, Type, Flags, EntrySize, Group, UniqueID,
- nullptr);
+ return getELFSection(Section, Type, Flags, EntrySize, Group,
+ MCSection::NonUniqueID, nullptr);
}
MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
unsigned Flags, unsigned EntrySize,
const Twine &Group, unsigned UniqueID,
- const MCSymbolELF *Associated);
+ const MCSymbolELF *LinkedToSym);
MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
unsigned Flags, unsigned EntrySize,
const MCSymbolELF *Group, unsigned UniqueID,
- const MCSymbolELF *Associated);
+ const MCSymbolELF *LinkedToSym);
/// Get a section with the provided group identifier. This section is
/// named by concatenating \p Prefix with '.' then \p Suffix. The \p Type
@@ -461,6 +519,17 @@
MCSectionELF *createELFGroupSection(const MCSymbolELF *Group);
+ void recordELFMergeableSectionInfo(StringRef SectionName, unsigned Flags,
+ unsigned UniqueID, unsigned EntrySize);
+
+ bool isELFImplicitMergeableSectionNamePrefix(StringRef Name);
+
+ bool isELFGenericMergeableSection(StringRef Name);
+
+ Optional<unsigned> getELFUniqueIDForEntsize(StringRef SectionName,
+ unsigned Flags,
+ unsigned EntrySize);
+
MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
SectionKind Kind, StringRef COMDATSymName,
int Selection,
@@ -503,7 +572,8 @@
MCSectionXCOFF *getXCOFFSection(StringRef Section,
XCOFF::StorageMappingClass MappingClass,
- SectionKind K,
+ XCOFF::SymbolType CSectType, SectionKind K,
+ bool MultiSymbolsAllowed = false,
const char *BeginSymName = nullptr);
// Create and save a copy of STI and return a reference to the copy.
@@ -534,7 +604,7 @@
const std::string &getMainFileName() const { return MainFileName; }
/// Set the main file name and override the default.
- void setMainFileName(StringRef S) { MainFileName = S; }
+ void setMainFileName(StringRef S) { MainFileName = std::string(S); }
/// Creates an entry in the dwarf file and directory tables.
Expected<unsigned> getDwarfFile(StringRef Directory, StringRef FileName,
@@ -644,10 +714,8 @@
void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; }
StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
- dwarf::DwarfFormat getDwarfFormat() const {
- // TODO: Support DWARF64
- return dwarf::DWARF32;
- }
+ void setDwarfFormat(dwarf::DwarfFormat f) { DwarfFormat = f; }
+ dwarf::DwarfFormat getDwarfFormat() const { return DwarfFormat; }
void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
uint16_t getDwarfVersion() const { return DwarfVersion; }
@@ -672,6 +740,7 @@
bool hadError() { return HadError; }
void reportError(SMLoc L, const Twine &Msg);
+ void reportWarning(SMLoc L, const Twine &Msg);
// Unrecoverable error has occurred. Display the best diagnostic we can
// and bail via exit(1). For now, most MC backend errors are unrecoverable.
// FIXME: We should really do something about that.
@@ -688,6 +757,8 @@
}
void undefineMacro(StringRef Name) { MacroMap.erase(Name); }
+
+ MCPseudoProbeTable &getMCPseudoProbeTable() { return PseudoProbeTable; }
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCDirectives.h b/linux-x64/clang/include/llvm/MC/MCDirectives.h
index 4029264..51e57ad 100644
--- a/linux-x64/clang/include/llvm/MC/MCDirectives.h
+++ b/linux-x64/clang/include/llvm/MC/MCDirectives.h
@@ -16,33 +16,35 @@
namespace llvm {
enum MCSymbolAttr {
- MCSA_Invalid = 0, ///< Not a valid directive.
+ MCSA_Invalid = 0, ///< Not a valid directive.
// Various directives in alphabetical order.
- MCSA_Cold, ///< .cold (MachO)
- MCSA_ELF_TypeFunction, ///< .type _foo, STT_FUNC # aka @function
- MCSA_ELF_TypeIndFunction, ///< .type _foo, STT_GNU_IFUNC
- MCSA_ELF_TypeObject, ///< .type _foo, STT_OBJECT # aka @object
- MCSA_ELF_TypeTLS, ///< .type _foo, STT_TLS # aka @tls_object
- MCSA_ELF_TypeCommon, ///< .type _foo, STT_COMMON # aka @common
- MCSA_ELF_TypeNoType, ///< .type _foo, STT_NOTYPE # aka @notype
+ MCSA_Cold, ///< .cold (MachO)
+ MCSA_ELF_TypeFunction, ///< .type _foo, STT_FUNC # aka @function
+ MCSA_ELF_TypeIndFunction, ///< .type _foo, STT_GNU_IFUNC
+ MCSA_ELF_TypeObject, ///< .type _foo, STT_OBJECT # aka @object
+ MCSA_ELF_TypeTLS, ///< .type _foo, STT_TLS # aka @tls_object
+ MCSA_ELF_TypeCommon, ///< .type _foo, STT_COMMON # aka @common
+ MCSA_ELF_TypeNoType, ///< .type _foo, STT_NOTYPE # aka @notype
MCSA_ELF_TypeGnuUniqueObject, /// .type _foo, @gnu_unique_object
- MCSA_Global, ///< .globl
- MCSA_Hidden, ///< .hidden (ELF)
- MCSA_IndirectSymbol, ///< .indirect_symbol (MachO)
- MCSA_Internal, ///< .internal (ELF)
- MCSA_LazyReference, ///< .lazy_reference (MachO)
- MCSA_Local, ///< .local (ELF)
- MCSA_NoDeadStrip, ///< .no_dead_strip (MachO)
- MCSA_SymbolResolver, ///< .symbol_resolver (MachO)
- MCSA_AltEntry, ///< .alt_entry (MachO)
- MCSA_PrivateExtern, ///< .private_extern (MachO)
- MCSA_Protected, ///< .protected (ELF)
- MCSA_Reference, ///< .reference (MachO)
- MCSA_Weak, ///< .weak
- MCSA_WeakDefinition, ///< .weak_definition (MachO)
- MCSA_WeakReference, ///< .weak_reference (MachO)
- MCSA_WeakDefAutoPrivate ///< .weak_def_can_be_hidden (MachO)
+ MCSA_Global, ///< .globl
+ MCSA_LGlobal, ///< .lglobl (XCOFF)
+ MCSA_Extern, ///< .extern (XCOFF)
+ MCSA_Hidden, ///< .hidden (ELF)
+ MCSA_IndirectSymbol, ///< .indirect_symbol (MachO)
+ MCSA_Internal, ///< .internal (ELF)
+ MCSA_LazyReference, ///< .lazy_reference (MachO)
+ MCSA_Local, ///< .local (ELF)
+ MCSA_NoDeadStrip, ///< .no_dead_strip (MachO)
+ MCSA_SymbolResolver, ///< .symbol_resolver (MachO)
+ MCSA_AltEntry, ///< .alt_entry (MachO)
+ MCSA_PrivateExtern, ///< .private_extern (MachO)
+ MCSA_Protected, ///< .protected (ELF)
+ MCSA_Reference, ///< .reference (MachO)
+ MCSA_Weak, ///< .weak
+ MCSA_WeakDefinition, ///< .weak_definition (MachO)
+ MCSA_WeakReference, ///< .weak_reference (MachO)
+ MCSA_WeakDefAutoPrivate ///< .weak_def_can_be_hidden (MachO)
};
enum MCAssemblerFlag {
diff --git a/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h b/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h
index 268f3cc..10037cd 100644
--- a/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h
+++ b/linux-x64/clang/include/llvm/MC/MCDisassembler/MCDisassembler.h
@@ -9,14 +9,63 @@
#ifndef LLVM_MC_MCDISASSEMBLER_MCDISASSEMBLER_H
#define LLVM_MC_MCDISASSEMBLER_MCDISASSEMBLER_H
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/XCOFF.h"
#include "llvm/MC/MCDisassembler/MCSymbolizer.h"
#include <cstdint>
#include <memory>
+#include <vector>
namespace llvm {
+struct XCOFFSymbolInfo {
+ Optional<XCOFF::StorageMappingClass> StorageMappingClass;
+ Optional<uint32_t> Index;
+ bool IsLabel;
+ XCOFFSymbolInfo(Optional<XCOFF::StorageMappingClass> Smc,
+ Optional<uint32_t> Idx, bool Label)
+ : StorageMappingClass(Smc), Index(Idx), IsLabel(Label) {}
+
+ bool operator<(const XCOFFSymbolInfo &SymInfo) const;
+};
+
+struct SymbolInfoTy {
+ uint64_t Addr;
+ StringRef Name;
+ union {
+ uint8_t Type;
+ XCOFFSymbolInfo XCOFFSymInfo;
+ };
+
+private:
+ bool IsXCOFF;
+
+public:
+ SymbolInfoTy(uint64_t Addr, StringRef Name,
+ Optional<XCOFF::StorageMappingClass> Smc, Optional<uint32_t> Idx,
+ bool Label)
+ : Addr(Addr), Name(Name), XCOFFSymInfo(Smc, Idx, Label), IsXCOFF(true) {}
+ SymbolInfoTy(uint64_t Addr, StringRef Name, uint8_t Type)
+ : Addr(Addr), Name(Name), Type(Type), IsXCOFF(false) {}
+ bool isXCOFF() const { return IsXCOFF; }
+
+private:
+ friend bool operator<(const SymbolInfoTy &P1, const SymbolInfoTy &P2) {
+ assert(P1.IsXCOFF == P2.IsXCOFF &&
+ "P1.IsXCOFF should be equal to P2.IsXCOFF.");
+ if (P1.IsXCOFF)
+ return std::tie(P1.Addr, P1.XCOFFSymInfo, P1.Name) <
+ std::tie(P2.Addr, P2.XCOFFSymInfo, P2.Name);
+
+ return std::tie(P1.Addr, P1.Name, P1.Type) <
+ std::tie(P2.Addr, P2.Name, P2.Type);
+ }
+};
+
+using SectionSymbolsTy = std::vector<SymbolInfoTy>;
+
template <typename T> class ArrayRef;
-class StringRef;
class MCContext;
class MCInst;
class MCSubtargetInfo;
@@ -69,7 +118,6 @@
/// \param Address - The address, in the memory space of region, of the first
/// byte of the instruction.
/// \param Bytes - A reference to the actual bytes of the instruction.
- /// \param VStream - The stream to print warnings and diagnostic messages on.
/// \param CStream - The stream to print comments and annotations on.
/// \return - MCDisassembler::Success if the instruction is valid,
/// MCDisassembler::SoftFail if the instruction was
@@ -77,25 +125,42 @@
/// MCDisassembler::Fail if the instruction was invalid.
virtual DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
ArrayRef<uint8_t> Bytes, uint64_t Address,
- raw_ostream &VStream,
raw_ostream &CStream) const = 0;
- /// May parse any prelude that precedes instructions after the start of a
- /// symbol. Needed for some targets, e.g. WebAssembly.
+ /// Used to perform separate target specific disassembly for a particular
+ /// symbol. May parse any prelude that precedes instructions after the
+ /// start of a symbol, or the entire symbol.
+ /// This is used for example by WebAssembly to decode preludes.
///
- /// \param Name - The name of the symbol.
+ /// Base implementation returns None. So all targets by default ignore to
+ /// treat symbols separately.
+ ///
+ /// \param Symbol - The symbol.
/// \param Size - The number of bytes consumed.
/// \param Address - The address, in the memory space of region, of the first
/// byte of the symbol.
/// \param Bytes - A reference to the actual bytes at the symbol location.
- /// \param VStream - The stream to print warnings and diagnostic messages on.
/// \param CStream - The stream to print comments and annotations on.
- /// \return - MCDisassembler::Success if the bytes are valid,
- /// MCDisassembler::Fail if the bytes were invalid.
- virtual DecodeStatus onSymbolStart(StringRef Name, uint64_t &Size,
- ArrayRef<uint8_t> Bytes, uint64_t Address,
- raw_ostream &VStream,
- raw_ostream &CStream) const;
+ /// \return - MCDisassembler::Success if bytes are decoded
+ /// successfully. Size must hold the number of bytes that
+ /// were decoded.
+ /// - MCDisassembler::Fail if the bytes are invalid. Size
+ /// must hold the number of bytes that were decoded before
+ /// failing. The target must print nothing. This can be
+ /// done by buffering the output if needed.
+ /// - None if the target doesn't want to handle the symbol
+ /// separately. Value of Size is ignored in this case.
+ virtual Optional<DecodeStatus>
+ onSymbolStart(SymbolInfoTy &Symbol, uint64_t &Size, ArrayRef<uint8_t> Bytes,
+ uint64_t Address, raw_ostream &CStream) const;
+ // TODO:
+ // Implement similar hooks that can be used at other points during
+ // disassembly. Something along the following lines:
+ // - onBeforeInstructionDecode()
+ // - onAfterInstructionDecode()
+ // - onSymbolEnd()
+ // It should help move much of the target specific code from llvm-objdump to
+ // respective target disassemblers.
private:
MCContext &Ctx;
diff --git a/linux-x64/clang/include/llvm/MC/MCDwarf.h b/linux-x64/clang/include/llvm/MC/MCDwarf.h
index 1a37aaf..70da5f7 100644
--- a/linux-x64/clang/include/llvm/MC/MCDwarf.h
+++ b/linux-x64/clang/include/llvm/MC/MCDwarf.h
@@ -41,6 +41,11 @@
class SMLoc;
class SourceMgr;
+namespace mcdwarf {
+// Emit the common part of the DWARF 5 range/locations list tables header.
+MCSymbol *emitListsTableHeaderStart(MCStreamer &S);
+} // namespace mcdwarf
+
/// Instances of this class represent the name of the dwarf .file directive and
/// its associated dwarf file number in the MC file. MCDwarfFile's are created
/// and uniqued by the MCContext class. In Dwarf 4 file numbers start from 1;
@@ -54,7 +59,7 @@
std::string Name;
// The index into the list of directory names for this file name.
- unsigned DirIndex;
+ unsigned DirIndex = 0;
/// The MD5 checksum, if there is one. Non-owning pointer to data allocated
/// in MCContext.
@@ -252,8 +257,8 @@
void setRootFile(StringRef Directory, StringRef FileName,
Optional<MD5::MD5Result> Checksum,
Optional<StringRef> Source) {
- CompilationDir = Directory;
- RootFile.Name = FileName;
+ CompilationDir = std::string(Directory);
+ RootFile.Name = std::string(FileName);
RootFile.DirIndex = 0;
RootFile.Checksum = Checksum;
RootFile.Source = Source;
@@ -325,8 +330,8 @@
void setRootFile(StringRef Directory, StringRef FileName,
Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
- Header.CompilationDir = Directory;
- Header.RootFile.Name = FileName;
+ Header.CompilationDir = std::string(Directory);
+ Header.RootFile.Name = std::string(FileName);
Header.RootFile.DirIndex = 0;
Header.RootFile.Checksum = Checksum;
Header.RootFile.Source = Source;
@@ -462,10 +467,12 @@
unsigned Register2;
};
std::vector<char> Values;
+ std::string Comment;
- MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V)
+ MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V,
+ StringRef Comment = "")
: Operation(Op), Label(L), Register(R), Offset(O),
- Values(V.begin(), V.end()) {
+ Values(V.begin(), V.end()), Comment(Comment) {
assert(Op != OpRegister);
}
@@ -477,9 +484,9 @@
public:
/// .cfi_def_cfa defines a rule for computing CFA as: take address from
/// Register and add Offset to it.
- static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register,
- int Offset) {
- return MCCFIInstruction(OpDefCfa, L, Register, -Offset, "");
+ static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register,
+ int Offset) {
+ return MCCFIInstruction(OpDefCfa, L, Register, Offset, "");
}
/// .cfi_def_cfa_register modifies a rule for computing CFA. From now
@@ -491,8 +498,8 @@
/// .cfi_def_cfa_offset modifies a rule for computing CFA. Register
/// remains the same, but offset is new. Note that it is the absolute offset
/// that will be added to a defined register to the compute CFA address.
- static MCCFIInstruction createDefCfaOffset(MCSymbol *L, int Offset) {
- return MCCFIInstruction(OpDefCfaOffset, L, 0, -Offset, "");
+ static MCCFIInstruction cfiDefCfaOffset(MCSymbol *L, int Offset) {
+ return MCCFIInstruction(OpDefCfaOffset, L, 0, Offset, "");
}
/// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but
@@ -565,8 +572,9 @@
/// .cfi_escape Allows the user to add arbitrary bytes to the unwind
/// info.
- static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals) {
- return MCCFIInstruction(OpEscape, L, 0, 0, Vals);
+ static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals,
+ StringRef Comment = "") {
+ return MCCFIInstruction(OpEscape, L, 0, 0, Vals, Comment);
}
/// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE
@@ -601,6 +609,10 @@
assert(Operation == OpEscape);
return StringRef(&Values[0], Values.size());
}
+
+ StringRef getComment() const {
+ return Comment;
+ }
};
struct MCDwarfFrameInfo {
@@ -629,7 +641,8 @@
static void Emit(MCObjectStreamer &streamer, MCAsmBackend *MAB, bool isEH);
static void EmitAdvanceLoc(MCObjectStreamer &Streamer, uint64_t AddrDelta);
static void EncodeAdvanceLoc(MCContext &Context, uint64_t AddrDelta,
- raw_ostream &OS);
+ raw_ostream &OS, uint32_t *Offset = nullptr,
+ uint32_t *Size = nullptr);
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h
index 2d441fd..5d99c49 100644
--- a/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCELFObjectWriter.h
@@ -23,7 +23,6 @@
class MCAssembler;
class MCContext;
class MCFixup;
-class MCObjectWriter;
class MCSymbol;
class MCSymbolELF;
class MCValue;
@@ -65,7 +64,7 @@
public:
virtual ~MCELFObjectTargetWriter() = default;
- virtual Triple::ObjectFormatType getFormat() const { return Triple::ELF; }
+ Triple::ObjectFormatType getFormat() const override { return Triple::ELF; }
static bool classof(const MCObjectTargetWriter *W) {
return W->getFormat() == Triple::ELF;
}
@@ -130,14 +129,10 @@
}
// N64 relocation type setting
- unsigned setRType(unsigned Value, unsigned Type) const {
- return ((Type & R_TYPE_MASK) | ((Value & 0xff) << R_TYPE_SHIFT));
- }
- unsigned setRType2(unsigned Value, unsigned Type) const {
- return (Type & R_TYPE2_MASK) | ((Value & 0xff) << R_TYPE2_SHIFT);
- }
- unsigned setRType3(unsigned Value, unsigned Type) const {
- return (Type & R_TYPE3_MASK) | ((Value & 0xff) << R_TYPE3_SHIFT);
+ static unsigned setRTypes(unsigned Value1, unsigned Value2, unsigned Value3) {
+ return ((Value1 & 0xff) << R_TYPE_SHIFT) |
+ ((Value2 & 0xff) << R_TYPE2_SHIFT) |
+ ((Value3 & 0xff) << R_TYPE3_SHIFT);
}
unsigned setRSsym(unsigned Value, unsigned Type) const {
return (Type & R_SSYM_MASK) | ((Value & 0xff) << R_SSYM_SHIFT);
diff --git a/linux-x64/clang/include/llvm/MC/MCELFStreamer.h b/linux-x64/clang/include/llvm/MC/MCELFStreamer.h
index 8838d53..f11629d 100644
--- a/linux-x64/clang/include/llvm/MC/MCELFStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCELFStreamer.h
@@ -39,49 +39,50 @@
/// @{
void InitSections(bool NoExecStack) override;
- void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
- void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
- void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F) override;
- void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
- void EmitThumbFunc(MCSymbol *Func) override;
- void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
- bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
- void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
- void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+ void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+ void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F,
+ uint64_t Offset) override;
+ void emitAssemblerFlag(MCAssemblerFlag Flag) override;
+ void emitThumbFunc(MCSymbol *Func) override;
+ void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+ bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+ void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
+ void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
void emitELFSymverDirective(StringRef AliasName,
const MCSymbol *Aliasee) override;
- void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
- void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+ void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
uint64_t Size = 0, unsigned ByteAlignment = 0,
SMLoc L = SMLoc()) override;
- void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+ void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment = 0) override;
- void EmitValueImpl(const MCExpr *Value, unsigned Size,
+ void emitValueImpl(const MCExpr *Value, unsigned Size,
SMLoc Loc = SMLoc()) override;
- void EmitIdent(StringRef IdentString) override;
+ void emitIdent(StringRef IdentString) override;
- void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
+ void emitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
void emitCGProfileEntry(const MCSymbolRefExpr *From,
const MCSymbolRefExpr *To, uint64_t Count) override;
- void FinishImpl() override;
+ void finishImpl() override;
- void EmitBundleAlignMode(unsigned AlignPow2) override;
- void EmitBundleLock(bool AlignToEnd) override;
- void EmitBundleUnlock() override;
+ void emitBundleAlignMode(unsigned AlignPow2) override;
+ void emitBundleLock(bool AlignToEnd) override;
+ void emitBundleUnlock() override;
private:
bool isBundleLocked() const;
- void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
- void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+ void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
+ void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
void fixSymbolsInTLSFixups(const MCExpr *expr);
void finalizeCGProfileEntry(const MCSymbolRefExpr *&S);
@@ -101,7 +102,7 @@
std::unique_ptr<MCAsmBackend> TAB,
std::unique_ptr<MCObjectWriter> OW,
std::unique_ptr<MCCodeEmitter> Emitter,
- bool RelaxAll, bool IsThumb);
+ bool RelaxAll, bool IsThumb, bool IsAndroid);
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCExpr.h b/linux-x64/clang/include/llvm/MC/MCExpr.h
index 7d9b265..3ffc845 100644
--- a/linux-x64/clang/include/llvm/MC/MCExpr.h
+++ b/linux-x64/clang/include/llvm/MC/MCExpr.h
@@ -34,7 +34,7 @@
/// needed for parsing.
class MCExpr {
public:
- enum ExprKind {
+ enum ExprKind : uint8_t {
Binary, ///< Binary expressions.
Constant, ///< Constant expressions.
SymbolRef, ///< References to labels and assigned expressions.
@@ -43,25 +43,34 @@
};
private:
- ExprKind Kind;
- SMLoc Loc;
+ static const unsigned NumSubclassDataBits = 24;
+ static_assert(
+ NumSubclassDataBits == CHAR_BIT * (sizeof(unsigned) - sizeof(ExprKind)),
+ "ExprKind and SubclassData together should take up one word");
- bool evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
- const MCAsmLayout *Layout,
- const SectionAddrMap *Addrs) const;
+ ExprKind Kind;
+ /// Field reserved for use by MCExpr subclasses.
+ unsigned SubclassData : NumSubclassDataBits;
+ SMLoc Loc;
bool evaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
const MCAsmLayout *Layout,
const SectionAddrMap *Addrs, bool InSet) const;
protected:
- explicit MCExpr(ExprKind Kind, SMLoc Loc) : Kind(Kind), Loc(Loc) {}
+ explicit MCExpr(ExprKind Kind, SMLoc Loc, unsigned SubclassData = 0)
+ : Kind(Kind), SubclassData(SubclassData), Loc(Loc) {
+ assert(SubclassData < (1 << NumSubclassDataBits) &&
+ "Subclass data too large");
+ }
bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
const MCAsmLayout *Layout,
const MCFixup *Fixup,
const SectionAddrMap *Addrs, bool InSet) const;
+ unsigned getSubclassData() const { return SubclassData; }
+
public:
MCExpr(const MCExpr &) = delete;
MCExpr &operator=(const MCExpr &) = delete;
@@ -135,20 +144,38 @@
class MCConstantExpr : public MCExpr {
int64_t Value;
- explicit MCConstantExpr(int64_t Value)
- : MCExpr(MCExpr::Constant, SMLoc()), Value(Value) {}
+ // Subclass data stores SizeInBytes in bits 0..7 and PrintInHex in bit 8.
+ static const unsigned SizeInBytesBits = 8;
+ static const unsigned SizeInBytesMask = (1 << SizeInBytesBits) - 1;
+ static const unsigned PrintInHexBit = 1 << SizeInBytesBits;
+
+ static unsigned encodeSubclassData(bool PrintInHex, unsigned SizeInBytes) {
+ assert(SizeInBytes <= sizeof(int64_t) && "Excessive size");
+ return SizeInBytes | (PrintInHex ? PrintInHexBit : 0);
+ }
+
+ MCConstantExpr(int64_t Value, bool PrintInHex, unsigned SizeInBytes)
+ : MCExpr(MCExpr::Constant, SMLoc(),
+ encodeSubclassData(PrintInHex, SizeInBytes)), Value(Value) {}
public:
/// \name Construction
/// @{
- static const MCConstantExpr *create(int64_t Value, MCContext &Ctx);
+ static const MCConstantExpr *create(int64_t Value, MCContext &Ctx,
+ bool PrintInHex = false,
+ unsigned SizeInBytes = 0);
/// @}
/// \name Accessors
/// @{
int64_t getValue() const { return Value; }
+ unsigned getSizeInBytes() const {
+ return getSubclassData() & SizeInBytesMask;
+ }
+
+ bool useHexFormat() const { return (getSubclassData() & PrintInHexBit) != 0; }
/// @}
@@ -171,6 +198,7 @@
VK_GOT,
VK_GOTOFF,
VK_GOTREL,
+ VK_PCREL,
VK_GOTPCREL,
VK_GOTTPOFF,
VK_INDNTPOFF,
@@ -182,9 +210,9 @@
VK_TLSLDM,
VK_TPOFF,
VK_DTPOFF,
- VK_TLSCALL, // symbol(tlscall)
- VK_TLSDESC, // symbol(tlsdesc)
- VK_TLVP, // Mach-O thread local variable relocations
+ VK_TLSCALL, // symbol(tlscall)
+ VK_TLSDESC, // symbol(tlsdesc)
+ VK_TLVP, // Mach-O thread local variable relocations
VK_TLVPPAGE,
VK_TLVPPAGEOFF,
VK_PAGE,
@@ -192,18 +220,19 @@
VK_GOTPAGE,
VK_GOTPAGEOFF,
VK_SECREL,
- VK_SIZE, // symbol@SIZE
- VK_WEAKREF, // The link between the symbols in .weakref foo, bar
+ VK_SIZE, // symbol@SIZE
+ VK_WEAKREF, // The link between the symbols in .weakref foo, bar
VK_X86_ABS8,
+ VK_X86_PLTOFF,
VK_ARM_NONE,
VK_ARM_GOT_PREL,
VK_ARM_TARGET1,
VK_ARM_TARGET2,
VK_ARM_PREL31,
- VK_ARM_SBREL, // symbol(sbrel)
- VK_ARM_TLSLDO, // symbol(tlsldo)
+ VK_ARM_SBREL, // symbol(sbrel)
+ VK_ARM_TLSLDO, // symbol(tlsldo)
VK_ARM_TLSDESCSEQ,
VK_AVR_NONE,
@@ -214,66 +243,74 @@
VK_AVR_DIFF16,
VK_AVR_DIFF32,
- VK_PPC_LO, // symbol@l
- VK_PPC_HI, // symbol@h
- VK_PPC_HA, // symbol@ha
- VK_PPC_HIGH, // symbol@high
- VK_PPC_HIGHA, // symbol@higha
- VK_PPC_HIGHER, // symbol@higher
- VK_PPC_HIGHERA, // symbol@highera
- VK_PPC_HIGHEST, // symbol@highest
- VK_PPC_HIGHESTA, // symbol@highesta
- VK_PPC_GOT_LO, // symbol@got@l
- VK_PPC_GOT_HI, // symbol@got@h
- VK_PPC_GOT_HA, // symbol@got@ha
- VK_PPC_TOCBASE, // symbol@tocbase
- VK_PPC_TOC, // symbol@toc
- VK_PPC_TOC_LO, // symbol@toc@l
- VK_PPC_TOC_HI, // symbol@toc@h
- VK_PPC_TOC_HA, // symbol@toc@ha
- VK_PPC_DTPMOD, // symbol@dtpmod
- VK_PPC_TPREL_LO, // symbol@tprel@l
- VK_PPC_TPREL_HI, // symbol@tprel@h
- VK_PPC_TPREL_HA, // symbol@tprel@ha
- VK_PPC_TPREL_HIGH, // symbol@tprel@high
- VK_PPC_TPREL_HIGHA, // symbol@tprel@higha
- VK_PPC_TPREL_HIGHER, // symbol@tprel@higher
- VK_PPC_TPREL_HIGHERA, // symbol@tprel@highera
- VK_PPC_TPREL_HIGHEST, // symbol@tprel@highest
- VK_PPC_TPREL_HIGHESTA, // symbol@tprel@highesta
- VK_PPC_DTPREL_LO, // symbol@dtprel@l
- VK_PPC_DTPREL_HI, // symbol@dtprel@h
- VK_PPC_DTPREL_HA, // symbol@dtprel@ha
- VK_PPC_DTPREL_HIGH, // symbol@dtprel@high
- VK_PPC_DTPREL_HIGHA, // symbol@dtprel@higha
- VK_PPC_DTPREL_HIGHER, // symbol@dtprel@higher
- VK_PPC_DTPREL_HIGHERA, // symbol@dtprel@highera
- VK_PPC_DTPREL_HIGHEST, // symbol@dtprel@highest
- VK_PPC_DTPREL_HIGHESTA,// symbol@dtprel@highesta
- VK_PPC_GOT_TPREL, // symbol@got@tprel
- VK_PPC_GOT_TPREL_LO, // symbol@got@tprel@l
- VK_PPC_GOT_TPREL_HI, // symbol@got@tprel@h
- VK_PPC_GOT_TPREL_HA, // symbol@got@tprel@ha
- VK_PPC_GOT_DTPREL, // symbol@got@dtprel
- VK_PPC_GOT_DTPREL_LO, // symbol@got@dtprel@l
- VK_PPC_GOT_DTPREL_HI, // symbol@got@dtprel@h
- VK_PPC_GOT_DTPREL_HA, // symbol@got@dtprel@ha
- VK_PPC_TLS, // symbol@tls
- VK_PPC_GOT_TLSGD, // symbol@got@tlsgd
- VK_PPC_GOT_TLSGD_LO, // symbol@got@tlsgd@l
- VK_PPC_GOT_TLSGD_HI, // symbol@got@tlsgd@h
- VK_PPC_GOT_TLSGD_HA, // symbol@got@tlsgd@ha
- VK_PPC_TLSGD, // symbol@tlsgd
- VK_PPC_GOT_TLSLD, // symbol@got@tlsld
- VK_PPC_GOT_TLSLD_LO, // symbol@got@tlsld@l
- VK_PPC_GOT_TLSLD_HI, // symbol@got@tlsld@h
- VK_PPC_GOT_TLSLD_HA, // symbol@got@tlsld@ha
- VK_PPC_TLSLD, // symbol@tlsld
- VK_PPC_LOCAL, // symbol@local
+ VK_PPC_LO, // symbol@l
+ VK_PPC_HI, // symbol@h
+ VK_PPC_HA, // symbol@ha
+ VK_PPC_HIGH, // symbol@high
+ VK_PPC_HIGHA, // symbol@higha
+ VK_PPC_HIGHER, // symbol@higher
+ VK_PPC_HIGHERA, // symbol@highera
+ VK_PPC_HIGHEST, // symbol@highest
+ VK_PPC_HIGHESTA, // symbol@highesta
+ VK_PPC_GOT_LO, // symbol@got@l
+ VK_PPC_GOT_HI, // symbol@got@h
+ VK_PPC_GOT_HA, // symbol@got@ha
+ VK_PPC_TOCBASE, // symbol@tocbase
+ VK_PPC_TOC, // symbol@toc
+ VK_PPC_TOC_LO, // symbol@toc@l
+ VK_PPC_TOC_HI, // symbol@toc@h
+ VK_PPC_TOC_HA, // symbol@toc@ha
+ VK_PPC_U, // symbol@u
+ VK_PPC_L, // symbol@l
+ VK_PPC_DTPMOD, // symbol@dtpmod
+ VK_PPC_TPREL_LO, // symbol@tprel@l
+ VK_PPC_TPREL_HI, // symbol@tprel@h
+ VK_PPC_TPREL_HA, // symbol@tprel@ha
+ VK_PPC_TPREL_HIGH, // symbol@tprel@high
+ VK_PPC_TPREL_HIGHA, // symbol@tprel@higha
+ VK_PPC_TPREL_HIGHER, // symbol@tprel@higher
+ VK_PPC_TPREL_HIGHERA, // symbol@tprel@highera
+ VK_PPC_TPREL_HIGHEST, // symbol@tprel@highest
+ VK_PPC_TPREL_HIGHESTA, // symbol@tprel@highesta
+ VK_PPC_DTPREL_LO, // symbol@dtprel@l
+ VK_PPC_DTPREL_HI, // symbol@dtprel@h
+ VK_PPC_DTPREL_HA, // symbol@dtprel@ha
+ VK_PPC_DTPREL_HIGH, // symbol@dtprel@high
+ VK_PPC_DTPREL_HIGHA, // symbol@dtprel@higha
+ VK_PPC_DTPREL_HIGHER, // symbol@dtprel@higher
+ VK_PPC_DTPREL_HIGHERA, // symbol@dtprel@highera
+ VK_PPC_DTPREL_HIGHEST, // symbol@dtprel@highest
+ VK_PPC_DTPREL_HIGHESTA, // symbol@dtprel@highesta
+ VK_PPC_GOT_TPREL, // symbol@got@tprel
+ VK_PPC_GOT_TPREL_LO, // symbol@got@tprel@l
+ VK_PPC_GOT_TPREL_HI, // symbol@got@tprel@h
+ VK_PPC_GOT_TPREL_HA, // symbol@got@tprel@ha
+ VK_PPC_GOT_DTPREL, // symbol@got@dtprel
+ VK_PPC_GOT_DTPREL_LO, // symbol@got@dtprel@l
+ VK_PPC_GOT_DTPREL_HI, // symbol@got@dtprel@h
+ VK_PPC_GOT_DTPREL_HA, // symbol@got@dtprel@ha
+ VK_PPC_TLS, // symbol@tls
+ VK_PPC_GOT_TLSGD, // symbol@got@tlsgd
+ VK_PPC_GOT_TLSGD_LO, // symbol@got@tlsgd@l
+ VK_PPC_GOT_TLSGD_HI, // symbol@got@tlsgd@h
+ VK_PPC_GOT_TLSGD_HA, // symbol@got@tlsgd@ha
+ VK_PPC_TLSGD, // symbol@tlsgd
+ VK_PPC_GOT_TLSLD, // symbol@got@tlsld
+ VK_PPC_GOT_TLSLD_LO, // symbol@got@tlsld@l
+ VK_PPC_GOT_TLSLD_HI, // symbol@got@tlsld@h
+ VK_PPC_GOT_TLSLD_HA, // symbol@got@tlsld@ha
+ VK_PPC_GOT_PCREL, // symbol@got@pcrel
+ VK_PPC_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel
+ VK_PPC_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel
+ VK_PPC_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel
+ VK_PPC_TLS_PCREL, // symbol@tls@pcrel
+ VK_PPC_TLSLD, // symbol@tlsld
+ VK_PPC_LOCAL, // symbol@local
+ VK_PPC_NOTOC, // symbol@notoc
+ VK_PPC_PCREL_OPT, // .reloc expr, R_PPC64_PCREL_OPT, expr
VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
- VK_Hexagon_PCREL,
VK_Hexagon_LO16,
VK_Hexagon_HI16,
VK_Hexagon_GPREL,
@@ -285,8 +322,9 @@
VK_Hexagon_IE_GOT,
VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
- VK_WASM_MBREL, // Memory address relative to memory base
- VK_WASM_TBREL, // Table index relative to table bare
+ VK_WASM_TLSREL, // Memory address relative to __tls_base
+ VK_WASM_MBREL, // Memory address relative to __memory_base
+ VK_WASM_TBREL, // Table index relative to __table_base
VK_AMDGPU_GOTPCREL32_LO, // symbol@gotpcrel32@lo
VK_AMDGPU_GOTPCREL32_HI, // symbol@gotpcrel32@hi
@@ -296,23 +334,43 @@
VK_AMDGPU_ABS32_LO, // symbol@abs32@lo
VK_AMDGPU_ABS32_HI, // symbol@abs32@hi
+ VK_VE_HI32, // symbol@hi
+ VK_VE_LO32, // symbol@lo
+ VK_VE_PC_HI32, // symbol@pc_hi
+ VK_VE_PC_LO32, // symbol@pc_lo
+ VK_VE_GOT_HI32, // symbol@got_hi
+ VK_VE_GOT_LO32, // symbol@got_lo
+ VK_VE_GOTOFF_HI32, // symbol@gotoff_hi
+ VK_VE_GOTOFF_LO32, // symbol@gotoff_lo
+ VK_VE_PLT_HI32, // symbol@plt_hi
+ VK_VE_PLT_LO32, // symbol@plt_lo
+ VK_VE_TLS_GD_HI32, // symbol@tls_gd_hi
+ VK_VE_TLS_GD_LO32, // symbol@tls_gd_lo
+ VK_VE_TPOFF_HI32, // symbol@tpoff_hi
+ VK_VE_TPOFF_LO32, // symbol@tpoff_lo
+
VK_TPREL,
VK_DTPREL
};
private:
- /// The symbol reference modifier.
- const VariantKind Kind;
-
- /// Specifies how the variant kind should be printed.
- const unsigned UseParensForSymbolVariant : 1;
-
- // FIXME: Remove this bit.
- const unsigned HasSubsectionsViaSymbols : 1;
-
/// The symbol being referenced.
const MCSymbol *Symbol;
+ // Subclass data stores VariantKind in bits 0..15 and HasSubsectionsViaSymbols
+ // in bit 16.
+ static const unsigned VariantKindBits = 16;
+ static const unsigned VariantKindMask = (1 << VariantKindBits) - 1;
+
+ // FIXME: Remove this bit.
+ static const unsigned HasSubsectionsViaSymbolsBit = 1 << VariantKindBits;
+
+ static unsigned encodeSubclassData(VariantKind Kind,
+ bool HasSubsectionsViaSymbols) {
+ return (unsigned)Kind |
+ (HasSubsectionsViaSymbols ? HasSubsectionsViaSymbolsBit : 0);
+ }
+
explicit MCSymbolRefExpr(const MCSymbol *Symbol, VariantKind Kind,
const MCAsmInfo *MAI, SMLoc Loc = SMLoc());
@@ -335,11 +393,13 @@
const MCSymbol &getSymbol() const { return *Symbol; }
- VariantKind getKind() const { return Kind; }
+ VariantKind getKind() const {
+ return (VariantKind)(getSubclassData() & VariantKindMask);
+ }
- void printVariantKind(raw_ostream &OS) const;
-
- bool hasSubsectionsViaSymbols() const { return HasSubsectionsViaSymbols; }
+ bool hasSubsectionsViaSymbols() const {
+ return (getSubclassData() & HasSubsectionsViaSymbolsBit) != 0;
+ }
/// @}
/// \name Static Utility Functions
@@ -367,11 +427,10 @@
};
private:
- Opcode Op;
const MCExpr *Expr;
MCUnaryExpr(Opcode Op, const MCExpr *Expr, SMLoc Loc)
- : MCExpr(MCExpr::Unary, Loc), Op(Op), Expr(Expr) {}
+ : MCExpr(MCExpr::Unary, Loc, Op), Expr(Expr) {}
public:
/// \name Construction
@@ -401,7 +460,7 @@
/// @{
/// Get the kind of this unary expression.
- Opcode getOpcode() const { return Op; }
+ Opcode getOpcode() const { return (Opcode)getSubclassData(); }
/// Get the child of this unary expression.
const MCExpr *getSubExpr() const { return Expr; }
@@ -435,6 +494,7 @@
Mul, ///< Multiplication.
NE, ///< Inequality comparison.
Or, ///< Bitwise or.
+ OrNot, ///< Bitwise or not.
Shl, ///< Shift left.
AShr, ///< Arithmetic shift right.
LShr, ///< Logical shift right.
@@ -443,12 +503,11 @@
};
private:
- Opcode Op;
const MCExpr *LHS, *RHS;
MCBinaryExpr(Opcode Op, const MCExpr *LHS, const MCExpr *RHS,
SMLoc Loc = SMLoc())
- : MCExpr(MCExpr::Binary, Loc), Op(Op), LHS(LHS), RHS(RHS) {}
+ : MCExpr(MCExpr::Binary, Loc, Op), LHS(LHS), RHS(RHS) {}
public:
/// \name Construction
@@ -558,7 +617,7 @@
/// @{
/// Get the kind of this binary expression.
- Opcode getOpcode() const { return Op; }
+ Opcode getOpcode() const { return (Opcode)getSubclassData(); }
/// Get the left-hand side expression of the binary operator.
const MCExpr *getLHS() const { return LHS; }
diff --git a/linux-x64/clang/include/llvm/MC/MCFixup.h b/linux-x64/clang/include/llvm/MC/MCFixup.h
index accffb7..b3a2391 100644
--- a/linux-x64/clang/include/llvm/MC/MCFixup.h
+++ b/linux-x64/clang/include/llvm/MC/MCFixup.h
@@ -9,7 +9,6 @@
#ifndef LLVM_MC_MCFIXUP_H
#define LLVM_MC_MCFIXUP_H
-#include "llvm/MC/MCExpr.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SMLoc.h"
@@ -20,41 +19,49 @@
/// Extensible enumeration to represent the type of a fixup.
enum MCFixupKind {
- FK_NONE = 0, ///< A no-op fixup.
- FK_Data_1, ///< A one-byte fixup.
- FK_Data_2, ///< A two-byte fixup.
- FK_Data_4, ///< A four-byte fixup.
- FK_Data_8, ///< A eight-byte fixup.
- FK_PCRel_1, ///< A one-byte pc relative fixup.
- FK_PCRel_2, ///< A two-byte pc relative fixup.
- FK_PCRel_4, ///< A four-byte pc relative fixup.
- FK_PCRel_8, ///< A eight-byte pc relative fixup.
- FK_GPRel_1, ///< A one-byte gp relative fixup.
- FK_GPRel_2, ///< A two-byte gp relative fixup.
- FK_GPRel_4, ///< A four-byte gp relative fixup.
- FK_GPRel_8, ///< A eight-byte gp relative fixup.
- FK_DTPRel_4, ///< A four-byte dtp relative fixup.
- FK_DTPRel_8, ///< A eight-byte dtp relative fixup.
- FK_TPRel_4, ///< A four-byte tp relative fixup.
- FK_TPRel_8, ///< A eight-byte tp relative fixup.
- FK_SecRel_1, ///< A one-byte section relative fixup.
- FK_SecRel_2, ///< A two-byte section relative fixup.
- FK_SecRel_4, ///< A four-byte section relative fixup.
- FK_SecRel_8, ///< A eight-byte section relative fixup.
- FK_Data_Add_1, ///< A one-byte add fixup.
- FK_Data_Add_2, ///< A two-byte add fixup.
- FK_Data_Add_4, ///< A four-byte add fixup.
- FK_Data_Add_8, ///< A eight-byte add fixup.
- FK_Data_Sub_1, ///< A one-byte sub fixup.
- FK_Data_Sub_2, ///< A two-byte sub fixup.
- FK_Data_Sub_4, ///< A four-byte sub fixup.
- FK_Data_Sub_8, ///< A eight-byte sub fixup.
+ FK_NONE = 0, ///< A no-op fixup.
+ FK_Data_1, ///< A one-byte fixup.
+ FK_Data_2, ///< A two-byte fixup.
+ FK_Data_4, ///< A four-byte fixup.
+ FK_Data_8, ///< A eight-byte fixup.
+ FK_Data_6b, ///< A six-bits fixup.
+ FK_PCRel_1, ///< A one-byte pc relative fixup.
+ FK_PCRel_2, ///< A two-byte pc relative fixup.
+ FK_PCRel_4, ///< A four-byte pc relative fixup.
+ FK_PCRel_8, ///< A eight-byte pc relative fixup.
+ FK_GPRel_1, ///< A one-byte gp relative fixup.
+ FK_GPRel_2, ///< A two-byte gp relative fixup.
+ FK_GPRel_4, ///< A four-byte gp relative fixup.
+ FK_GPRel_8, ///< A eight-byte gp relative fixup.
+ FK_DTPRel_4, ///< A four-byte dtp relative fixup.
+ FK_DTPRel_8, ///< A eight-byte dtp relative fixup.
+ FK_TPRel_4, ///< A four-byte tp relative fixup.
+ FK_TPRel_8, ///< A eight-byte tp relative fixup.
+ FK_SecRel_1, ///< A one-byte section relative fixup.
+ FK_SecRel_2, ///< A two-byte section relative fixup.
+ FK_SecRel_4, ///< A four-byte section relative fixup.
+ FK_SecRel_8, ///< A eight-byte section relative fixup.
+ FK_Data_Add_1, ///< A one-byte add fixup.
+ FK_Data_Add_2, ///< A two-byte add fixup.
+ FK_Data_Add_4, ///< A four-byte add fixup.
+ FK_Data_Add_8, ///< A eight-byte add fixup.
+ FK_Data_Add_6b, ///< A six-bits add fixup.
+ FK_Data_Sub_1, ///< A one-byte sub fixup.
+ FK_Data_Sub_2, ///< A two-byte sub fixup.
+ FK_Data_Sub_4, ///< A four-byte sub fixup.
+ FK_Data_Sub_8, ///< A eight-byte sub fixup.
+ FK_Data_Sub_6b, ///< A six-bits sub fixup.
FirstTargetFixupKind = 128,
- // Limit range of target fixups, in case we want to pack more efficiently
- // later.
- MaxTargetFixupKind = (1 << 8)
+ /// The range [FirstLiteralRelocationKind, MaxTargetFixupKind) is used for
+ /// relocations coming from .reloc directive. Fixup kind
+ /// FirstLiteralRelocationKind+V represents the relocation type with number V.
+ FirstLiteralRelocationKind = 256,
+
+ /// Set limit to accommodate the highest reloc type in use for all Targets,
+ /// currently R_AARCH64_IRELATIVE at 1032, including room for expansion.
+ MaxFixupKind = FirstLiteralRelocationKind + 1032 + 32,
};
/// Encode information on a single operation to perform on a byte
@@ -75,25 +82,25 @@
/// The value to put into the fixup location. The exact interpretation of the
/// expression is target dependent, usually it will be one of the operands to
/// an instruction or an assembler directive.
- const MCExpr *Value;
+ const MCExpr *Value = nullptr;
/// The byte index of start of the relocation inside the MCFragment.
- uint32_t Offset;
+ uint32_t Offset = 0;
/// The target dependent kind of fixup item this is. The kind is used to
/// determine how the operand value should be encoded into the instruction.
- unsigned Kind;
+ MCFixupKind Kind = FK_NONE;
/// The source location which gave rise to the fixup, if any.
SMLoc Loc;
public:
static MCFixup create(uint32_t Offset, const MCExpr *Value,
MCFixupKind Kind, SMLoc Loc = SMLoc()) {
- assert(unsigned(Kind) < MaxTargetFixupKind && "Kind out of range!");
+ assert(Kind <= MaxFixupKind && "Kind out of range!");
MCFixup FI;
FI.Value = Value;
FI.Offset = Offset;
- FI.Kind = unsigned(Kind);
+ FI.Kind = Kind;
FI.Loc = Loc;
return FI;
}
@@ -104,7 +111,7 @@
MCFixup FI;
FI.Value = Fixup.getValue();
FI.Offset = Fixup.getOffset();
- FI.Kind = (unsigned)getAddKindForKind(Fixup.getKind());
+ FI.Kind = getAddKindForKind(Fixup.getKind());
FI.Loc = Fixup.getLoc();
return FI;
}
@@ -115,12 +122,14 @@
MCFixup FI;
FI.Value = Fixup.getValue();
FI.Offset = Fixup.getOffset();
- FI.Kind = (unsigned)getSubKindForKind(Fixup.getKind());
+ FI.Kind = getSubKindForKind(Fixup.getKind());
FI.Loc = Fixup.getLoc();
return FI;
}
- MCFixupKind getKind() const { return MCFixupKind(Kind); }
+ MCFixupKind getKind() const { return Kind; }
+
+ unsigned getTargetKind() const { return Kind; }
uint32_t getOffset() const { return Offset; }
void setOffset(uint32_t Value) { Offset = Value; }
@@ -129,37 +138,63 @@
/// Return the generic fixup kind for a value with the given size. It
/// is an error to pass an unsupported size.
- static MCFixupKind getKindForSize(unsigned Size, bool isPCRel) {
+ static MCFixupKind getKindForSize(unsigned Size, bool IsPCRel) {
switch (Size) {
default: llvm_unreachable("Invalid generic fixup size!");
- case 1: return isPCRel ? FK_PCRel_1 : FK_Data_1;
- case 2: return isPCRel ? FK_PCRel_2 : FK_Data_2;
- case 4: return isPCRel ? FK_PCRel_4 : FK_Data_4;
- case 8: return isPCRel ? FK_PCRel_8 : FK_Data_8;
+ case 1:
+ return IsPCRel ? FK_PCRel_1 : FK_Data_1;
+ case 2:
+ return IsPCRel ? FK_PCRel_2 : FK_Data_2;
+ case 4:
+ return IsPCRel ? FK_PCRel_4 : FK_Data_4;
+ case 8:
+ return IsPCRel ? FK_PCRel_8 : FK_Data_8;
+ }
+ }
+
+ /// Return the generic fixup kind for a value with the given size in bits.
+ /// It is an error to pass an unsupported size.
+ static MCFixupKind getKindForSizeInBits(unsigned Size, bool IsPCRel) {
+ switch (Size) {
+ default:
+ llvm_unreachable("Invalid generic fixup size!");
+ case 6:
+ assert(!IsPCRel && "Invalid pc-relative fixup size!");
+ return FK_Data_6b;
+ case 8:
+ return IsPCRel ? FK_PCRel_1 : FK_Data_1;
+ case 16:
+ return IsPCRel ? FK_PCRel_2 : FK_Data_2;
+ case 32:
+ return IsPCRel ? FK_PCRel_4 : FK_Data_4;
+ case 64:
+ return IsPCRel ? FK_PCRel_8 : FK_Data_8;
}
}
/// Return the generic fixup kind for an addition with a given size. It
/// is an error to pass an unsupported size.
- static MCFixupKind getAddKindForKind(unsigned Kind) {
+ static MCFixupKind getAddKindForKind(MCFixupKind Kind) {
switch (Kind) {
default: llvm_unreachable("Unknown type to convert!");
case FK_Data_1: return FK_Data_Add_1;
case FK_Data_2: return FK_Data_Add_2;
case FK_Data_4: return FK_Data_Add_4;
case FK_Data_8: return FK_Data_Add_8;
+ case FK_Data_6b: return FK_Data_Add_6b;
}
}
/// Return the generic fixup kind for an subtraction with a given size. It
/// is an error to pass an unsupported size.
- static MCFixupKind getSubKindForKind(unsigned Kind) {
+ static MCFixupKind getSubKindForKind(MCFixupKind Kind) {
switch (Kind) {
default: llvm_unreachable("Unknown type to convert!");
case FK_Data_1: return FK_Data_Sub_1;
case FK_Data_2: return FK_Data_Sub_2;
case FK_Data_4: return FK_Data_Sub_4;
case FK_Data_8: return FK_Data_Sub_8;
+ case FK_Data_6b: return FK_Data_Sub_6b;
}
}
diff --git a/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h b/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h
index 0ea3486..ecf85fa 100644
--- a/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCFixupKindInfo.h
@@ -19,7 +19,15 @@
FKF_IsPCRel = (1 << 0),
/// Should this fixup kind force a 4-byte aligned effective PC value?
- FKF_IsAlignedDownTo32Bits = (1 << 1)
+ FKF_IsAlignedDownTo32Bits = (1 << 1),
+
+ /// Should this fixup be evaluated in a target dependent manner?
+ FKF_IsTarget = (1 << 2),
+
+ /// This fixup kind should be resolved if defined.
+ /// FIXME This is a workaround because we don't support certain ARM
+ /// relocation types. This flag should eventually be removed.
+ FKF_Constant = 1 << 3,
};
/// A target specific name for the fixup kind. The names will be unique for
diff --git a/linux-x64/clang/include/llvm/MC/MCFragment.h b/linux-x64/clang/include/llvm/MC/MCFragment.h
index aadf2ce..000b0e3 100644
--- a/linux-x64/clang/include/llvm/MC/MCFragment.h
+++ b/linux-x64/clang/include/llvm/MC/MCFragment.h
@@ -16,6 +16,7 @@
#include "llvm/ADT/ilist_node.h"
#include "llvm/MC/MCFixup.h"
#include "llvm/MC/MCInst.h"
+#include "llvm/Support/Alignment.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/SMLoc.h"
#include <cstdint>
@@ -36,52 +37,49 @@
FT_Data,
FT_CompactEncodedInst,
FT_Fill,
+ FT_Nops,
FT_Relaxable,
FT_Org,
FT_Dwarf,
FT_DwarfFrame,
FT_LEB,
- FT_Padding,
+ FT_BoundaryAlign,
FT_SymbolId,
FT_CVInlineLines,
FT_CVDefRange,
+ FT_PseudoProbe,
FT_Dummy
};
private:
+ /// The data for the section this fragment is in.
+ MCSection *Parent;
+
+ /// The atom this fragment is in, as represented by its defining symbol.
+ const MCSymbol *Atom;
+
+ /// The offset of this fragment in its section. This is ~0 until
+ /// initialized.
+ uint64_t Offset;
+
+ /// The layout order of this fragment.
+ unsigned LayoutOrder;
+
+ /// The subsection this fragment belongs to. This is 0 if the fragment is not
+ // in any subsection.
+ unsigned SubsectionNumber = 0;
+
FragmentType Kind;
+ /// Whether fragment is being laid out.
+ bool IsBeingLaidOut;
+
protected:
bool HasInstructions;
-private:
- /// LayoutOrder - The layout order of this fragment.
- unsigned LayoutOrder;
-
- /// The data for the section this fragment is in.
- MCSection *Parent;
-
- /// Atom - The atom this fragment is in, as represented by its defining
- /// symbol.
- const MCSymbol *Atom;
-
- /// \name Assembler Backend Data
- /// @{
- //
- // FIXME: This could all be kept private to the assembler implementation.
-
- /// Offset - The offset of this fragment in its section. This is ~0 until
- /// initialized.
- uint64_t Offset;
-
- /// @}
-
-protected:
MCFragment(FragmentType Kind, bool HasInstructions,
MCSection *Parent = nullptr);
- ~MCFragment();
-
public:
MCFragment() = delete;
MCFragment(const MCFragment &) = delete;
@@ -108,10 +106,10 @@
/// this is false, but specific fragment types may set it to true.
bool hasInstructions() const { return HasInstructions; }
- /// Return true if given frgment has FT_Dummy type.
- bool isDummy() const { return Kind == FT_Dummy; }
-
void dump() const;
+
+ void setSubsectionNumber(unsigned Value) { SubsectionNumber = Value; }
+ unsigned getSubsectionNumber() const { return SubsectionNumber; }
};
class MCDummyFragment : public MCFragment {
@@ -135,8 +133,8 @@
MCSection *Sec)
: MCFragment(FType, HasInstructions, Sec) {}
- /// STI - The MCSubtargetInfo in effect when the instruction was encoded.
- /// must be non-null for instructions.
+ /// The MCSubtargetInfo in effect when the instruction was encoded.
+ /// It must be non-null for instructions.
const MCSubtargetInfo *STI = nullptr;
public:
@@ -149,6 +147,8 @@
case MCFragment::FT_CompactEncodedInst:
case MCFragment::FT_Data:
case MCFragment::FT_Dwarf:
+ case MCFragment::FT_DwarfFrame:
+ case MCFragment::FT_PseudoProbe:
return true;
}
}
@@ -205,7 +205,7 @@
class MCEncodedFragmentWithFixups :
public MCEncodedFragmentWithContents<ContentsSize> {
- /// Fixups - The list of fixups in this fragment.
+ /// The list of fixups in this fragment.
SmallVector<MCFixup, FixupsSize> Fixups;
protected:
@@ -232,7 +232,8 @@
static bool classof(const MCFragment *F) {
MCFragment::FragmentType Kind = F->getKind();
return Kind == MCFragment::FT_Relaxable || Kind == MCFragment::FT_Data ||
- Kind == MCFragment::FT_CVDefRange || Kind == MCFragment::FT_Dwarf;;
+ Kind == MCFragment::FT_CVDefRange || Kind == MCFragment::FT_Dwarf ||
+ Kind == MCFragment::FT_DwarfFrame;
}
};
@@ -269,8 +270,10 @@
///
class MCRelaxableFragment : public MCEncodedFragmentWithFixups<8, 1> {
- /// Inst - The instruction this is a fragment for.
+ /// The instruction this is a fragment for.
MCInst Inst;
+ /// Can we auto pad the instruction?
+ bool AllowAutoPadding = false;
public:
MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI,
@@ -281,27 +284,30 @@
const MCInst &getInst() const { return Inst; }
void setInst(const MCInst &Value) { Inst = Value; }
+ bool getAllowAutoPadding() const { return AllowAutoPadding; }
+ void setAllowAutoPadding(bool V) { AllowAutoPadding = V; }
+
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_Relaxable;
}
};
class MCAlignFragment : public MCFragment {
- /// Alignment - The alignment to ensure, in bytes.
+ /// The alignment to ensure, in bytes.
unsigned Alignment;
- /// EmitNops - Flag to indicate that (optimal) NOPs should be emitted instead
+ /// Flag to indicate that (optimal) NOPs should be emitted instead
/// of using the provided value. The exact interpretation of this flag is
/// target dependent.
bool EmitNops : 1;
- /// Value - Value to use for filling padding bytes.
+ /// Value to use for filling padding bytes.
int64_t Value;
- /// ValueSize - The size of the integer (in bytes) of \p Value.
+ /// The size of the integer (in bytes) of \p Value.
unsigned ValueSize;
- /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
+ /// The maximum number of bytes to emit; if the alignment
/// cannot be satisfied in this width then this fragment is ignored.
unsigned MaxBytesToEmit;
@@ -311,9 +317,6 @@
: MCFragment(FT_Align, false, Sec), Alignment(Alignment), EmitNops(false),
Value(Value), ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
- /// \name Accessors
- /// @{
-
unsigned getAlignment() const { return Alignment; }
int64_t getValue() const { return Value; }
@@ -325,109 +328,15 @@
bool hasEmitNops() const { return EmitNops; }
void setEmitNops(bool Value) { EmitNops = Value; }
- /// @}
-
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_Align;
}
};
-/// Fragment for adding required padding.
-/// This fragment is always inserted before an instruction, and holds that
-/// instruction as context information (as well as a mask of kinds) for
-/// determining the padding size.
-///
-class MCPaddingFragment : public MCFragment {
- /// A mask containing all the kinds relevant to this fragment. i.e. the i'th
- /// bit will be set iff kind i is relevant to this fragment.
- uint64_t PaddingPoliciesMask;
- /// A boolean indicating if this fragment will actually hold padding. If its
- /// value is false, then this fragment serves only as a placeholder,
- /// containing data to assist other insertion point in their decision making.
- bool IsInsertionPoint;
-
- uint64_t Size;
-
- struct MCInstInfo {
- bool IsInitialized;
- MCInst Inst;
- /// A boolean indicating whether the instruction pointed by this fragment is
- /// a fixed size instruction or a relaxable instruction held by a
- /// MCRelaxableFragment.
- bool IsImmutableSizedInst;
- union {
- /// If the instruction is a fixed size instruction, hold its size.
- size_t InstSize;
- /// Otherwise, hold a pointer to the MCRelaxableFragment holding it.
- MCRelaxableFragment *InstFragment;
- };
- };
- MCInstInfo InstInfo;
-
-public:
- static const uint64_t PFK_None = UINT64_C(0);
-
- enum MCPaddingFragmentKind {
- // values 0-7 are reserved for future target independet values.
-
- FirstTargetPerfNopFragmentKind = 8,
-
- /// Limit range of target MCPerfNopFragment kinds to fit in uint64_t
- MaxTargetPerfNopFragmentKind = 63
- };
-
- MCPaddingFragment(MCSection *Sec = nullptr)
- : MCFragment(FT_Padding, false, Sec), PaddingPoliciesMask(PFK_None),
- IsInsertionPoint(false), Size(UINT64_C(0)),
- InstInfo({false, MCInst(), false, {0}}) {}
-
- bool isInsertionPoint() const { return IsInsertionPoint; }
- void setAsInsertionPoint() { IsInsertionPoint = true; }
- uint64_t getPaddingPoliciesMask() const { return PaddingPoliciesMask; }
- void setPaddingPoliciesMask(uint64_t Value) { PaddingPoliciesMask = Value; }
- bool hasPaddingPolicy(uint64_t PolicyMask) const {
- assert(isPowerOf2_64(PolicyMask) &&
- "Policy mask must contain exactly one policy");
- return (getPaddingPoliciesMask() & PolicyMask) != PFK_None;
- }
- const MCInst &getInst() const {
- assert(isInstructionInitialized() && "Fragment has no instruction!");
- return InstInfo.Inst;
- }
- size_t getInstSize() const {
- assert(isInstructionInitialized() && "Fragment has no instruction!");
- if (InstInfo.IsImmutableSizedInst)
- return InstInfo.InstSize;
- assert(InstInfo.InstFragment != nullptr &&
- "Must have a valid InstFragment to retrieve InstSize from");
- return InstInfo.InstFragment->getContents().size();
- }
- void setInstAndInstSize(const MCInst &Inst, size_t InstSize) {
- InstInfo.IsInitialized = true;
- InstInfo.IsImmutableSizedInst = true;
- InstInfo.Inst = Inst;
- InstInfo.InstSize = InstSize;
- }
- void setInstAndInstFragment(const MCInst &Inst,
- MCRelaxableFragment *InstFragment) {
- InstInfo.IsInitialized = true;
- InstInfo.IsImmutableSizedInst = false;
- InstInfo.Inst = Inst;
- InstInfo.InstFragment = InstFragment;
- }
- uint64_t getSize() const { return Size; }
- void setSize(uint64_t Value) { Size = Value; }
- bool isInstructionInitialized() const { return InstInfo.IsInitialized; }
-
- static bool classof(const MCFragment *F) {
- return F->getKind() == MCFragment::FT_Padding;
- }
-};
-
class MCFillFragment : public MCFragment {
+ uint8_t ValueSize;
/// Value to use for filling bytes.
uint64_t Value;
- uint8_t ValueSize;
/// The number of bytes to insert.
const MCExpr &NumValues;
@@ -437,7 +346,7 @@
public:
MCFillFragment(uint64_t Value, uint8_t VSize, const MCExpr &NumValues,
SMLoc Loc, MCSection *Sec = nullptr)
- : MCFragment(FT_Fill, false, Sec), Value(Value), ValueSize(VSize),
+ : MCFragment(FT_Fill, false, Sec), ValueSize(VSize), Value(Value),
NumValues(NumValues), Loc(Loc) {}
uint64_t getValue() const { return Value; }
@@ -451,23 +360,46 @@
}
};
-class MCOrgFragment : public MCFragment {
- /// The offset this fragment should start at.
- const MCExpr *Offset;
+class MCNopsFragment : public MCFragment {
+ /// The number of bytes to insert.
+ int64_t Size;
+ /// Maximum number of bytes allowed in each NOP instruction.
+ int64_t ControlledNopLength;
+ /// Source location of the directive that this fragment was created for.
+ SMLoc Loc;
+
+public:
+ MCNopsFragment(int64_t NumBytes, int64_t ControlledNopLength, SMLoc L,
+ MCSection *Sec = nullptr)
+ : MCFragment(FT_Nops, false, Sec), Size(NumBytes),
+ ControlledNopLength(ControlledNopLength), Loc(L) {}
+
+ int64_t getNumBytes() const { return Size; }
+ int64_t getControlledNopLength() const { return ControlledNopLength; }
+
+ SMLoc getLoc() const { return Loc; }
+
+ static bool classof(const MCFragment *F) {
+ return F->getKind() == MCFragment::FT_Nops;
+ }
+};
+
+class MCOrgFragment : public MCFragment {
/// Value to use for filling bytes.
int8_t Value;
+ /// The offset this fragment should start at.
+ const MCExpr *Offset;
+
/// Source location of the directive that this fragment was created for.
SMLoc Loc;
public:
MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc,
MCSection *Sec = nullptr)
- : MCFragment(FT_Org, false, Sec), Offset(&Offset), Value(Value), Loc(Loc) {}
-
- /// \name Accessors
- /// @{
+ : MCFragment(FT_Org, false, Sec), Value(Value), Offset(&Offset),
+ Loc(Loc) {}
const MCExpr &getOffset() const { return *Offset; }
@@ -475,31 +407,26 @@
SMLoc getLoc() const { return Loc; }
- /// @}
-
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_Org;
}
};
class MCLEBFragment : public MCFragment {
- /// Value - The value this fragment should contain.
- const MCExpr *Value;
-
- /// IsSigned - True if this is a sleb128, false if uleb128.
+ /// True if this is a sleb128, false if uleb128.
bool IsSigned;
+ /// The value this fragment should contain.
+ const MCExpr *Value;
+
SmallString<8> Contents;
public:
MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec = nullptr)
- : MCFragment(FT_LEB, false, Sec), Value(&Value_), IsSigned(IsSigned_) {
+ : MCFragment(FT_LEB, false, Sec), IsSigned(IsSigned_), Value(&Value_) {
Contents.push_back(0);
}
- /// \name Accessors
- /// @{
-
const MCExpr &getValue() const { return *Value; }
bool isSigned() const { return IsSigned; }
@@ -515,11 +442,11 @@
};
class MCDwarfLineAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {
- /// LineDelta - the value of the difference between the two line numbers
+ /// The value of the difference between the two line numbers
/// between two .loc dwarf directives.
int64_t LineDelta;
- /// AddrDelta - The expression for the difference of the two symbols that
+ /// The expression for the difference of the two symbols that
/// make up the address delta between two .loc dwarf directives.
const MCExpr *AddrDelta;
@@ -529,43 +456,27 @@
: MCEncodedFragmentWithFixups<8, 1>(FT_Dwarf, false, Sec),
LineDelta(LineDelta), AddrDelta(&AddrDelta) {}
- /// \name Accessors
- /// @{
-
int64_t getLineDelta() const { return LineDelta; }
const MCExpr &getAddrDelta() const { return *AddrDelta; }
- /// @}
-
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_Dwarf;
}
};
-class MCDwarfCallFrameFragment : public MCFragment {
- /// AddrDelta - The expression for the difference of the two symbols that
+class MCDwarfCallFrameFragment : public MCEncodedFragmentWithFixups<8, 1> {
+ /// The expression for the difference of the two symbols that
/// make up the address delta between two .cfi_* dwarf directives.
const MCExpr *AddrDelta;
- SmallString<8> Contents;
-
public:
MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec = nullptr)
- : MCFragment(FT_DwarfFrame, false, Sec), AddrDelta(&AddrDelta) {
- Contents.push_back(0);
- }
-
- /// \name Accessors
- /// @{
+ : MCEncodedFragmentWithFixups<8, 1>(FT_DwarfFrame, false, Sec),
+ AddrDelta(&AddrDelta) {}
const MCExpr &getAddrDelta() const { return *AddrDelta; }
- SmallString<8> &getContents() { return Contents; }
- const SmallString<8> &getContents() const { return Contents; }
-
- /// @}
-
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_DwarfFrame;
}
@@ -579,14 +490,9 @@
MCSymbolIdFragment(const MCSymbol *Sym, MCSection *Sec = nullptr)
: MCFragment(FT_SymbolId, false, Sec), Sym(Sym) {}
- /// \name Accessors
- /// @{
-
const MCSymbol *getSymbol() { return Sym; }
const MCSymbol *getSymbol() const { return Sym; }
- /// @}
-
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_SymbolId;
}
@@ -615,17 +521,12 @@
StartFileId(StartFileId), StartLineNum(StartLineNum),
FnStartSym(FnStartSym), FnEndSym(FnEndSym) {}
- /// \name Accessors
- /// @{
-
const MCSymbol *getFnStartSym() const { return FnStartSym; }
const MCSymbol *getFnEndSym() const { return FnEndSym; }
SmallString<8> &getContents() { return Contents; }
const SmallString<8> &getContents() const { return Contents; }
- /// @}
-
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_CVInlineLines;
}
@@ -648,20 +549,67 @@
Ranges(Ranges.begin(), Ranges.end()),
FixedSizePortion(FixedSizePortion) {}
- /// \name Accessors
- /// @{
ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> getRanges() const {
return Ranges;
}
StringRef getFixedSizePortion() const { return FixedSizePortion; }
- /// @}
static bool classof(const MCFragment *F) {
return F->getKind() == MCFragment::FT_CVDefRange;
}
};
+/// Represents required padding such that a particular other set of fragments
+/// does not cross a particular power-of-two boundary. The other fragments must
+/// follow this one within the same section.
+class MCBoundaryAlignFragment : public MCFragment {
+ /// The alignment requirement of the branch to be aligned.
+ Align AlignBoundary;
+ /// The last fragment in the set of fragments to be aligned.
+ const MCFragment *LastFragment = nullptr;
+ /// The size of the fragment. The size is lazily set during relaxation, and
+ /// is not meaningful before that.
+ uint64_t Size = 0;
+
+public:
+ MCBoundaryAlignFragment(Align AlignBoundary, MCSection *Sec = nullptr)
+ : MCFragment(FT_BoundaryAlign, false, Sec), AlignBoundary(AlignBoundary) {
+ }
+
+ uint64_t getSize() const { return Size; }
+ void setSize(uint64_t Value) { Size = Value; }
+
+ Align getAlignment() const { return AlignBoundary; }
+ void setAlignment(Align Value) { AlignBoundary = Value; }
+
+ const MCFragment *getLastFragment() const { return LastFragment; }
+ void setLastFragment(const MCFragment *F) {
+ assert(!F || getParent() == F->getParent());
+ LastFragment = F;
+ }
+
+ static bool classof(const MCFragment *F) {
+ return F->getKind() == MCFragment::FT_BoundaryAlign;
+ }
+};
+
+class MCPseudoProbeAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {
+ /// The expression for the difference of the two symbols that
+ /// make up the address delta between two .pseudoprobe directives.
+ const MCExpr *AddrDelta;
+
+public:
+ MCPseudoProbeAddrFragment(const MCExpr *AddrDelta, MCSection *Sec = nullptr)
+ : MCEncodedFragmentWithFixups<8, 1>(FT_PseudoProbe, false, Sec),
+ AddrDelta(AddrDelta) {}
+
+ const MCExpr &getAddrDelta() const { return *AddrDelta; }
+
+ static bool classof(const MCFragment *F) {
+ return F->getKind() == MCFragment::FT_PseudoProbe;
+ }
+};
} // end namespace llvm
#endif // LLVM_MC_MCFRAGMENT_H
diff --git a/linux-x64/clang/include/llvm/MC/MCInst.h b/linux-x64/clang/include/llvm/MC/MCInst.h
index 8df8096..2ce2ee0 100644
--- a/linux-x64/clang/include/llvm/MC/MCInst.h
+++ b/linux-x64/clang/include/llvm/MC/MCInst.h
@@ -157,13 +157,14 @@
/// instruction.
class MCInst {
unsigned Opcode = 0;
- SMLoc Loc;
- SmallVector<MCOperand, 8> Operands;
// These flags could be used to pass some info from one target subcomponent
// to another, for example, from disassembler to asm printer. The values of
// the flags have any sense on target level only (e.g. prefixes on x86).
unsigned Flags = 0;
+ SMLoc Loc;
+ SmallVector<MCOperand, 8> Operands;
+
public:
MCInst() = default;
@@ -180,7 +181,7 @@
MCOperand &getOperand(unsigned i) { return Operands[i]; }
unsigned getNumOperands() const { return Operands.size(); }
- void addOperand(const MCOperand &Op) { Operands.push_back(Op); }
+ void addOperand(const MCOperand Op) { Operands.push_back(Op); }
using iterator = SmallVectorImpl<MCOperand>::iterator;
using const_iterator = SmallVectorImpl<MCOperand>::const_iterator;
diff --git a/linux-x64/clang/include/llvm/MC/MCInstPrinter.h b/linux-x64/clang/include/llvm/MC/MCInstPrinter.h
index 6bbc4bc..8b9ef17 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstPrinter.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstPrinter.h
@@ -16,7 +16,9 @@
class MCAsmInfo;
class MCInst;
+class MCOperand;
class MCInstrInfo;
+class MCInstrAnalysis;
class MCRegisterInfo;
class MCSubtargetInfo;
class raw_ostream;
@@ -34,6 +36,8 @@
} // end namespace HexStyle
+struct AliasMatchingData;
+
/// This is an instance of a target assembly language printer that
/// converts an MCInst to valid target assembly syntax.
class MCInstPrinter {
@@ -45,6 +49,7 @@
const MCAsmInfo &MAI;
const MCInstrInfo &MII;
const MCRegisterInfo &MRI;
+ const MCInstrAnalysis *MIA = nullptr;
/// True if we are printing marked up assembly.
bool UseMarkup = false;
@@ -55,9 +60,21 @@
/// Which style to use for printing hexadecimal values.
HexStyle::Style PrintHexStyle = HexStyle::C;
+ /// If true, a branch immediate (e.g. bl 4) will be printed as a hexadecimal
+ /// address (e.g. bl 0x20004). This is useful for a stream disassembler
+ /// (llvm-objdump -d).
+ bool PrintBranchImmAsAddress = false;
+
+ /// If true, symbolize branch target and memory reference operands.
+ bool SymbolizeOperands = false;
+
/// Utility function for printing annotations.
void printAnnotation(raw_ostream &OS, StringRef Annot);
+ /// Helper for matching MCInsts to alias patterns when printing instructions.
+ const char *matchAliasPatterns(const MCInst *MI, const MCSubtargetInfo *STI,
+ const AliasMatchingData &M);
+
public:
MCInstPrinter(const MCAsmInfo &mai, const MCInstrInfo &mii,
const MCRegisterInfo &mri) : MAI(mai), MII(mii), MRI(mri) {}
@@ -71,9 +88,19 @@
/// Specify a stream to emit comments to.
void setCommentStream(raw_ostream &OS) { CommentStream = &OS; }
+ /// Returns a pair containing the mnemonic for \p MI and the number of bits
+ /// left for further processing by printInstruction (generated by tablegen).
+ virtual std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) = 0;
+
/// Print the specified MCInst to the specified raw_ostream.
- virtual void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot,
- const MCSubtargetInfo &STI) = 0;
+ ///
+ /// \p Address the address of current instruction on most targets, used to
+ /// print a PC relative immediate as the target address. On targets where a PC
+ /// relative immediate is relative to the next instruction and the length of a
+ /// MCInst is difficult to measure (e.g. x86), this is the address of the next
+ /// instruction. If Address is 0, the immediate will be printed.
+ virtual void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
+ const MCSubtargetInfo &STI, raw_ostream &OS) = 0;
/// Return the name of the specified opcode enum (e.g. "MOV32ri") or
/// empty if we can't resolve it.
@@ -87,14 +114,19 @@
/// Utility functions to make adding mark ups simpler.
StringRef markup(StringRef s) const;
- StringRef markup(StringRef a, StringRef b) const;
bool getPrintImmHex() const { return PrintImmHex; }
void setPrintImmHex(bool Value) { PrintImmHex = Value; }
- HexStyle::Style getPrintHexStyle() const { return PrintHexStyle; }
void setPrintHexStyle(HexStyle::Style Value) { PrintHexStyle = Value; }
+ void setPrintBranchImmAsAddress(bool Value) {
+ PrintBranchImmAsAddress = Value;
+ }
+
+ void setSymbolizeOperands(bool Value) { SymbolizeOperands = Value; }
+ void setMCInstrAnalysis(const MCInstrAnalysis *Value) { MIA = Value; }
+
/// Utility function to print immediates in decimal or hex.
format_object<int64_t> formatImm(int64_t Value) const {
return PrintImmHex ? formatHex(Value) : formatDec(Value);
@@ -106,6 +138,51 @@
format_object<uint64_t> formatHex(uint64_t Value) const;
};
+/// Map from opcode to pattern list by binary search.
+struct PatternsForOpcode {
+ uint32_t Opcode;
+ uint16_t PatternStart;
+ uint16_t NumPatterns;
+};
+
+/// Data for each alias pattern. Includes feature bits, string, number of
+/// operands, and a variadic list of conditions to check.
+struct AliasPattern {
+ uint32_t AsmStrOffset;
+ uint32_t AliasCondStart;
+ uint8_t NumOperands;
+ uint8_t NumConds;
+};
+
+struct AliasPatternCond {
+ enum CondKind : uint8_t {
+ K_Feature, // Match only if a feature is enabled.
+ K_NegFeature, // Match only if a feature is disabled.
+ K_OrFeature, // Match only if one of a set of features is enabled.
+ K_OrNegFeature, // Match only if one of a set of features is disabled.
+ K_EndOrFeatures, // Note end of list of K_Or(Neg)?Features.
+ K_Ignore, // Match any operand.
+ K_Reg, // Match a specific register.
+ K_TiedReg, // Match another already matched register.
+ K_Imm, // Match a specific immediate.
+ K_RegClass, // Match registers in a class.
+ K_Custom, // Call custom matcher by index.
+ };
+
+ CondKind Kind;
+ uint32_t Value;
+};
+
+/// Tablegenerated data structures needed to match alias patterns.
+struct AliasMatchingData {
+ ArrayRef<PatternsForOpcode> OpToPatterns;
+ ArrayRef<AliasPattern> Patterns;
+ ArrayRef<AliasPatternCond> PatternConds;
+ StringRef AsmStrings;
+ bool (*ValidateMCOperand)(const MCOperand &MCOp, const MCSubtargetInfo &STI,
+ unsigned PredicateIndex);
+};
+
} // end namespace llvm
#endif // LLVM_MC_MCINSTPRINTER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h b/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h
index dfefd7e..898ca47 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrAnalysis.h
@@ -152,6 +152,12 @@
evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
uint64_t &Target) const;
+ /// Given an instruction tries to get the address of a memory operand. Returns
+ /// the address on success.
+ virtual Optional<uint64_t> evaluateMemoryOperandAddress(const MCInst &Inst,
+ uint64_t Addr,
+ uint64_t Size) const;
+
/// Returns (PLT virtual address, GOT virtual address) pairs for PLT entries.
virtual std::vector<std::pair<uint64_t, uint64_t>>
findPltEntries(uint64_t PltSectionVA, ArrayRef<uint8_t> PltContents,
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrDesc.h b/linux-x64/clang/include/llvm/MC/MCInstrDesc.h
index 0aa586d..cbb061f 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrDesc.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrDesc.h
@@ -19,25 +19,39 @@
#include <string>
namespace llvm {
- class MCInst;
- class MCSubtargetInfo;
- class FeatureBitset;
+
+class MCInst;
//===----------------------------------------------------------------------===//
// Machine Operand Flags and Description
//===----------------------------------------------------------------------===//
namespace MCOI {
-// Operand constraints
+/// Operand constraints. These are encoded in 16 bits with one of the
+/// low-order 3 bits specifying that a constraint is present and the
+/// corresponding high-order hex digit specifying the constraint value.
+/// This allows for a maximum of 3 constraints.
enum OperandConstraint {
- TIED_TO = 0, // Must be allocated the same register as.
- EARLY_CLOBBER // Operand is an early clobber register operand
+ TIED_TO = 0, // Must be allocated the same register as specified value.
+ EARLY_CLOBBER // If present, operand is an early clobber register.
};
+// Define a macro to produce each constraint value.
+#define MCOI_TIED_TO(op) \
+ ((1 << MCOI::TIED_TO) | ((op) << (4 + MCOI::TIED_TO * 4)))
+
+#define MCOI_EARLY_CLOBBER \
+ (1 << MCOI::EARLY_CLOBBER)
+
/// These are flags set on operands, but should be considered
/// private, all access should go through the MCOperandInfo accessors.
/// See the accessors for a description of what these are.
-enum OperandFlags { LookupPtrRegClass = 0, Predicate, OptionalDef };
+enum OperandFlags {
+ LookupPtrRegClass = 0,
+ Predicate,
+ OptionalDef,
+ BranchTarget
+};
/// Operands are tagged with one of the values of this enum.
enum OperandType {
@@ -56,7 +70,11 @@
OPERAND_GENERIC_5 = 11,
OPERAND_LAST_GENERIC = 11,
- OPERAND_FIRST_TARGET = 12,
+ OPERAND_FIRST_GENERIC_IMM = 12,
+ OPERAND_GENERIC_IMM_0 = 12,
+ OPERAND_LAST_GENERIC_IMM = 12,
+
+ OPERAND_FIRST_TARGET = 13,
};
}
@@ -76,10 +94,9 @@
/// Information about the type of the operand.
uint8_t OperandType;
- /// The lower 16 bits are used to specify which constraints are set.
- /// The higher 16 bits are used to specify the value of constraints (4 bits
- /// each).
- uint32_t Constraints;
+
+ /// Operand constraints (see OperandConstraint enum).
+ uint16_t Constraints;
/// Set if this operand is a pointer value and it requires a callback
/// to look up its register class.
@@ -94,6 +111,9 @@
/// Set if this operand is a optional def.
bool isOptionalDef() const { return Flags & (1 << MCOI::OptionalDef); }
+ /// Set if this operand is a branch target.
+ bool isBranchTarget() const { return Flags & (1 << MCOI::BranchTarget); }
+
bool isGenericType() const {
return OperandType >= MCOI::OPERAND_FIRST_GENERIC &&
OperandType <= MCOI::OPERAND_LAST_GENERIC;
@@ -103,6 +123,16 @@
assert(isGenericType() && "non-generic types don't have an index");
return OperandType - MCOI::OPERAND_FIRST_GENERIC;
}
+
+ bool isGenericImm() const {
+ return OperandType >= MCOI::OPERAND_FIRST_GENERIC_IMM &&
+ OperandType <= MCOI::OPERAND_LAST_GENERIC_IMM;
+ }
+
+ unsigned getGenericImmIndex() const {
+ assert(isGenericImm() && "non-generic immediates don't have an index");
+ return OperandType - MCOI::OPERAND_FIRST_GENERIC_IMM;
+ }
};
//===----------------------------------------------------------------------===//
@@ -115,7 +145,8 @@
/// not use these directly. These all correspond to bitfields in the
/// MCInstrDesc::Flags field.
enum Flag {
- Variadic = 0,
+ PreISelOpcode = 0,
+ Variadic,
HasOptionalDef,
Pseudo,
Return,
@@ -153,6 +184,7 @@
Add,
Trap,
VariadicOpsAreDefs,
+ Authenticated,
};
}
@@ -173,33 +205,19 @@
const MCPhysReg *ImplicitUses; // Registers implicitly read by this instr
const MCPhysReg *ImplicitDefs; // Registers implicitly defined by this instr
const MCOperandInfo *OpInfo; // 'NumOperands' entries about operands
- // Subtarget feature that this is deprecated on, if any
- // -1 implies this is not deprecated by any single feature. It may still be
- // deprecated due to a "complex" reason, below.
- int64_t DeprecatedFeature;
- // A complex method to determine if a certain instruction is deprecated or
- // not, and return the reason for deprecation.
- bool (*ComplexDeprecationInfo)(MCInst &, const MCSubtargetInfo &,
- std::string &);
-
- /// Returns the value of the specific constraint if
- /// it is set. Returns -1 if it is not set.
+ /// Returns the value of the specified operand constraint if
+ /// it is present. Returns -1 if it is not present.
int getOperandConstraint(unsigned OpNum,
MCOI::OperandConstraint Constraint) const {
if (OpNum < NumOperands &&
(OpInfo[OpNum].Constraints & (1 << Constraint))) {
- unsigned Pos = 16 + Constraint * 4;
- return (int)(OpInfo[OpNum].Constraints >> Pos) & 0xf;
+ unsigned ValuePos = 4 + Constraint * 4;
+ return (int)(OpInfo[OpNum].Constraints >> ValuePos) & 0x0f;
}
return -1;
}
- /// Returns true if a certain instruction is deprecated and if so
- /// returns the reason in \p Info.
- bool getDeprecatedInfo(MCInst &MI, const MCSubtargetInfo &STI,
- std::string &Info) const;
-
/// Return the opcode number for this descriptor.
unsigned getOpcode() const { return Opcode; }
@@ -228,6 +246,10 @@
/// Return flags of this instruction.
uint64_t getFlags() const { return Flags; }
+ /// \returns true if this instruction is emitted before instruction selection
+ /// and should be legalized/regbankselected/selected.
+ bool isPreISelOpcode() const { return Flags & (1ULL << MCID::PreISelOpcode); }
+
/// Return true if this instruction can have a variable number of
/// operands. In this case, the variable operands will be after the normal
/// operands but before the implicit definitions and uses (if any are
@@ -272,7 +294,7 @@
/// Returns true if this is a conditional, unconditional, or
/// indirect branch. Predicates below can be used to discriminate between
- /// these cases, and the TargetInstrInfo::AnalyzeBranch method can be used to
+ /// these cases, and the TargetInstrInfo::analyzeBranch method can be used to
/// get more information.
bool isBranch() const { return Flags & (1ULL << MCID::Branch); }
@@ -282,18 +304,18 @@
/// Return true if this is a branch which may fall
/// through to the next instruction or may transfer control flow to some other
- /// block. The TargetInstrInfo::AnalyzeBranch method can be used to get more
+ /// block. The TargetInstrInfo::analyzeBranch method can be used to get more
/// information about this branch.
bool isConditionalBranch() const {
- return isBranch() & !isBarrier() & !isIndirectBranch();
+ return isBranch() && !isBarrier() && !isIndirectBranch();
}
/// Return true if this is a branch which always
/// transfers control flow to some other block. The
- /// TargetInstrInfo::AnalyzeBranch method can be used to get more information
+ /// TargetInstrInfo::analyzeBranch method can be used to get more information
/// about this branch.
bool isUnconditionalBranch() const {
- return isBranch() & isBarrier() & !isIndirectBranch();
+ return isBranch() && isBarrier() && !isIndirectBranch();
}
/// Return true if this is a branch or an instruction which directly
@@ -389,6 +411,15 @@
return Flags & (1ULL << MCID::VariadicOpsAreDefs);
}
+ /// Return true if this instruction authenticates a pointer (e.g. LDRAx/BRAx
+ /// from ARMv8.3, which perform loads/branches with authentication).
+ ///
+ /// An authenticated instruction may fail in an ABI-defined manner when
+ /// operating on an invalid signed pointer.
+ bool isAuthenticated() const {
+ return Flags & (1ULL << MCID::Authenticated);
+ }
+
//===--------------------------------------------------------------------===//
// Side Effect Analysis
//===--------------------------------------------------------------------===//
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrInfo.h b/linux-x64/clang/include/llvm/MC/MCInstrInfo.h
index 874b1e4..598e242 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrInfo.h
@@ -18,22 +18,40 @@
namespace llvm {
+class MCSubtargetInfo;
+
//---------------------------------------------------------------------------
/// Interface to description of machine instruction set.
class MCInstrInfo {
+public:
+ using ComplexDeprecationPredicate = bool (*)(MCInst &,
+ const MCSubtargetInfo &,
+ std::string &);
+
+private:
const MCInstrDesc *Desc; // Raw array to allow static init'n
const unsigned *InstrNameIndices; // Array for name indices in InstrNameData
const char *InstrNameData; // Instruction name string pool
+ // Subtarget feature that an instruction is deprecated on, if any
+ // -1 implies this is not deprecated by any single feature. It may still be
+ // deprecated due to a "complex" reason, below.
+ const uint8_t *DeprecatedFeatures;
+ // A complex method to determine if a certain instruction is deprecated or
+ // not, and return the reason for deprecation.
+ const ComplexDeprecationPredicate *ComplexDeprecationInfos;
unsigned NumOpcodes; // Number of entries in the desc array
public:
/// Initialize MCInstrInfo, called by TableGen auto-generated routines.
/// *DO NOT USE*.
void InitMCInstrInfo(const MCInstrDesc *D, const unsigned *NI, const char *ND,
- unsigned NO) {
+ const uint8_t *DF,
+ const ComplexDeprecationPredicate *CDI, unsigned NO) {
Desc = D;
InstrNameIndices = NI;
InstrNameData = ND;
+ DeprecatedFeatures = DF;
+ ComplexDeprecationInfos = CDI;
NumOpcodes = NO;
}
@@ -51,6 +69,11 @@
assert(Opcode < NumOpcodes && "Invalid opcode!");
return StringRef(&InstrNameData[InstrNameIndices[Opcode]]);
}
+
+ /// Returns true if a certain instruction is deprecated and if so
+ /// returns the reason in \p Info.
+ bool getDeprecatedInfo(MCInst &MI, const MCSubtargetInfo &STI,
+ std::string &Info) const;
};
} // End llvm namespace
diff --git a/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h b/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h
index 485aa66..652922f 100644
--- a/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h
+++ b/linux-x64/clang/include/llvm/MC/MCInstrItineraries.h
@@ -61,8 +61,11 @@
Reserved = 1
};
+ /// Bitmask representing a set of functional units.
+ typedef uint64_t FuncUnits;
+
unsigned Cycles_; ///< Length of stage in machine cycles
- unsigned Units_; ///< Choice of functional units
+ FuncUnits Units_; ///< Choice of functional units
int NextCycles_; ///< Number of machine cycles to next stage
ReservationKinds Kind_; ///< Kind of the FU reservation
@@ -72,7 +75,7 @@
}
/// Returns the choice of FUs.
- unsigned getUnits() const {
+ FuncUnits getUnits() const {
return Units_;
}
diff --git a/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h b/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h
index f2a1364..003491f 100644
--- a/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h
+++ b/linux-x64/clang/include/llvm/MC/MCLinkerOptimizationHint.h
@@ -61,6 +61,7 @@
MCLOHCaseNameToId(AdrpAdd)
MCLOHCaseNameToId(AdrpLdrGot)
.Default(-1);
+#undef MCLOHCaseNameToId
}
static inline StringRef MCLOHIdToName(MCLOHType Kind) {
@@ -76,6 +77,7 @@
MCLOHCaseIdToName(AdrpLdrGot);
}
return StringRef();
+#undef MCLOHCaseIdToName
}
static inline int MCLOHIdToNbArgs(MCLOHType Kind) {
diff --git a/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h
index 278aebe..f4f9c47 100644
--- a/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCMachObjectWriter.h
@@ -16,6 +16,7 @@
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCSection.h"
#include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Support/EndianStream.h"
#include <cstdint>
#include <memory>
#include <string>
@@ -28,7 +29,9 @@
class MCMachObjectTargetWriter : public MCObjectTargetWriter {
const unsigned Is64Bit : 1;
const uint32_t CPUType;
- const uint32_t CPUSubtype;
+protected:
+ uint32_t CPUSubtype;
+public:
unsigned LocalDifference_RIT;
protected:
@@ -42,7 +45,7 @@
public:
virtual ~MCMachObjectTargetWriter();
- virtual Triple::ObjectFormatType getFormat() const { return Triple::MachO; }
+ Triple::ObjectFormatType getFormat() const override { return Triple::MachO; }
static bool classof(const MCObjectTargetWriter *W) {
return W->getFormat() == Triple::MachO;
}
@@ -111,7 +114,7 @@
/// \name Symbol Table Data
/// @{
- StringTableBuilder StringTable{StringTableBuilder::MachO};
+ StringTableBuilder StringTable;
std::vector<MachSymbolData> LocalSymbolData;
std::vector<MachSymbolData> ExternalSymbolData;
std::vector<MachSymbolData> UndefinedSymbolData;
@@ -126,6 +129,8 @@
MachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
raw_pwrite_stream &OS, bool IsLittleEndian)
: TargetObjectWriter(std::move(MOTW)),
+ StringTable(TargetObjectWriter->is64Bit() ? StringTableBuilder::MachO64
+ : StringTableBuilder::MachO),
W(OS, IsLittleEndian ? support::little : support::big) {}
support::endian::Writer W;
@@ -230,16 +235,6 @@
Relocations[Sec].push_back(P);
}
- void recordScatteredRelocation(const MCAssembler &Asm,
- const MCAsmLayout &Layout,
- const MCFragment *Fragment,
- const MCFixup &Fixup, MCValue Target,
- unsigned Log2Size, uint64_t &FixedValue);
-
- void recordTLVPRelocation(const MCAssembler &Asm, const MCAsmLayout &Layout,
- const MCFragment *Fragment, const MCFixup &Fixup,
- MCValue Target, uint64_t &FixedValue);
-
void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
const MCFragment *Fragment, const MCFixup &Fixup,
MCValue Target, uint64_t &FixedValue) override;
diff --git a/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h b/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h
index abc87bf..2e6a84b 100644
--- a/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCObjectFileInfo.h
@@ -27,20 +27,20 @@
protected:
/// True if .comm supports alignment. This is a hack for as long as we
/// support 10.4 Tiger, whose assembler doesn't support alignment on comm.
- bool CommDirectiveSupportsAlignment;
+ bool CommDirectiveSupportsAlignment = false;
/// True if target object file supports a weak_definition of constant 0 for an
/// omitted EH frame.
- bool SupportsWeakOmittedEHFrame;
+ bool SupportsWeakOmittedEHFrame = false;
/// True if the target object file supports emitting a compact unwind section
/// without an associated EH frame section.
- bool SupportsCompactUnwindWithoutEHFrame;
+ bool SupportsCompactUnwindWithoutEHFrame = false;
/// OmitDwarfIfHaveCompactUnwind - True if the target object file
/// supports having some functions with compact unwind and other with
/// dwarf unwind.
- bool OmitDwarfIfHaveCompactUnwind;
+ bool OmitDwarfIfHaveCompactUnwind = false;
/// FDE CFI encoding. Controls the encoding of the begin label in the
/// .eh_frame section. Unlike the LSDA encoding, personality encoding, and
@@ -49,134 +49,141 @@
unsigned FDECFIEncoding = 0;
/// Compact unwind encoding indicating that we should emit only an EH frame.
- unsigned CompactUnwindDwarfEHFrameOnly;
+ unsigned CompactUnwindDwarfEHFrameOnly = 0;
/// Section directive for standard text.
- MCSection *TextSection;
+ MCSection *TextSection = nullptr;
/// Section directive for standard data.
- MCSection *DataSection;
+ MCSection *DataSection = nullptr;
/// Section that is default initialized to zero.
- MCSection *BSSSection;
+ MCSection *BSSSection = nullptr;
/// Section that is readonly and can contain arbitrary initialized data.
/// Targets are not required to have a readonly section. If they don't,
/// various bits of code will fall back to using the data section for
/// constants.
- MCSection *ReadOnlySection;
+ MCSection *ReadOnlySection = nullptr;
/// If exception handling is supported by the target, this is the section the
/// Language Specific Data Area information is emitted to.
- MCSection *LSDASection;
+ MCSection *LSDASection = nullptr;
/// If exception handling is supported by the target and the target can
/// support a compact representation of the CIE and FDE, this is the section
/// to emit them into.
- MCSection *CompactUnwindSection;
+ MCSection *CompactUnwindSection = nullptr;
// Dwarf sections for debug info. If a target supports debug info, these must
// be set.
- MCSection *DwarfAbbrevSection;
- MCSection *DwarfInfoSection;
- MCSection *DwarfLineSection;
- MCSection *DwarfLineStrSection;
- MCSection *DwarfFrameSection;
- MCSection *DwarfPubTypesSection;
- const MCSection *DwarfDebugInlineSection;
- MCSection *DwarfStrSection;
- MCSection *DwarfLocSection;
- MCSection *DwarfARangesSection;
- MCSection *DwarfRangesSection;
- MCSection *DwarfMacinfoSection;
+ MCSection *DwarfAbbrevSection = nullptr;
+ MCSection *DwarfInfoSection = nullptr;
+ MCSection *DwarfLineSection = nullptr;
+ MCSection *DwarfLineStrSection = nullptr;
+ MCSection *DwarfFrameSection = nullptr;
+ MCSection *DwarfPubTypesSection = nullptr;
+ const MCSection *DwarfDebugInlineSection = nullptr;
+ MCSection *DwarfStrSection = nullptr;
+ MCSection *DwarfLocSection = nullptr;
+ MCSection *DwarfARangesSection = nullptr;
+ MCSection *DwarfRangesSection = nullptr;
+ MCSection *DwarfMacinfoSection = nullptr;
+ MCSection *DwarfMacroSection = nullptr;
// The pubnames section is no longer generated by default. The generation
// can be enabled by a compiler flag.
- MCSection *DwarfPubNamesSection;
+ MCSection *DwarfPubNamesSection = nullptr;
/// Accelerator table sections. DwarfDebugNamesSection is the DWARF v5
/// accelerator table, while DwarfAccelNamesSection, DwarfAccelObjCSection,
/// DwarfAccelNamespaceSection, DwarfAccelTypesSection are pre-DWARF v5
/// extensions.
- MCSection *DwarfDebugNamesSection;
- MCSection *DwarfAccelNamesSection;
- MCSection *DwarfAccelObjCSection;
- MCSection *DwarfAccelNamespaceSection;
- MCSection *DwarfAccelTypesSection;
+ MCSection *DwarfDebugNamesSection = nullptr;
+ MCSection *DwarfAccelNamesSection = nullptr;
+ MCSection *DwarfAccelObjCSection = nullptr;
+ MCSection *DwarfAccelNamespaceSection = nullptr;
+ MCSection *DwarfAccelTypesSection = nullptr;
// These are used for the Fission separate debug information files.
- MCSection *DwarfInfoDWOSection;
- MCSection *DwarfTypesDWOSection;
- MCSection *DwarfAbbrevDWOSection;
- MCSection *DwarfStrDWOSection;
- MCSection *DwarfLineDWOSection;
- MCSection *DwarfLocDWOSection;
- MCSection *DwarfStrOffDWOSection;
+ MCSection *DwarfInfoDWOSection = nullptr;
+ MCSection *DwarfTypesDWOSection = nullptr;
+ MCSection *DwarfAbbrevDWOSection = nullptr;
+ MCSection *DwarfStrDWOSection = nullptr;
+ MCSection *DwarfLineDWOSection = nullptr;
+ MCSection *DwarfLocDWOSection = nullptr;
+ MCSection *DwarfStrOffDWOSection = nullptr;
+ MCSection *DwarfMacinfoDWOSection = nullptr;
+ MCSection *DwarfMacroDWOSection = nullptr;
/// The DWARF v5 string offset and address table sections.
- MCSection *DwarfStrOffSection;
- MCSection *DwarfAddrSection;
+ MCSection *DwarfStrOffSection = nullptr;
+ MCSection *DwarfAddrSection = nullptr;
/// The DWARF v5 range list section.
- MCSection *DwarfRnglistsSection;
+ MCSection *DwarfRnglistsSection = nullptr;
/// The DWARF v5 locations list section.
- MCSection *DwarfLoclistsSection;
+ MCSection *DwarfLoclistsSection = nullptr;
- /// The DWARF v5 range list section for fission.
- MCSection *DwarfRnglistsDWOSection;
+ /// The DWARF v5 range and location list sections for fission.
+ MCSection *DwarfRnglistsDWOSection = nullptr;
+ MCSection *DwarfLoclistsDWOSection = nullptr;
// These are for Fission DWP files.
- MCSection *DwarfCUIndexSection;
- MCSection *DwarfTUIndexSection;
+ MCSection *DwarfCUIndexSection = nullptr;
+ MCSection *DwarfTUIndexSection = nullptr;
/// Section for newer gnu pubnames.
- MCSection *DwarfGnuPubNamesSection;
+ MCSection *DwarfGnuPubNamesSection = nullptr;
/// Section for newer gnu pubtypes.
- MCSection *DwarfGnuPubTypesSection;
+ MCSection *DwarfGnuPubTypesSection = nullptr;
// Section for Swift AST
- MCSection *DwarfSwiftASTSection;
+ MCSection *DwarfSwiftASTSection = nullptr;
- MCSection *COFFDebugSymbolsSection;
- MCSection *COFFDebugTypesSection;
- MCSection *COFFGlobalTypeHashesSection;
+ MCSection *COFFDebugSymbolsSection = nullptr;
+ MCSection *COFFDebugTypesSection = nullptr;
+ MCSection *COFFGlobalTypeHashesSection = nullptr;
/// Extra TLS Variable Data section.
///
/// If the target needs to put additional information for a TLS variable,
/// it'll go here.
- MCSection *TLSExtraDataSection;
+ MCSection *TLSExtraDataSection = nullptr;
/// Section directive for Thread Local data. ELF, MachO, COFF, and Wasm.
- MCSection *TLSDataSection; // Defaults to ".tdata".
+ MCSection *TLSDataSection = nullptr; // Defaults to ".tdata".
/// Section directive for Thread Local uninitialized data.
///
/// Null if this target doesn't support a BSS section. ELF and MachO only.
- MCSection *TLSBSSSection; // Defaults to ".tbss".
+ MCSection *TLSBSSSection = nullptr; // Defaults to ".tbss".
/// StackMap section.
- MCSection *StackMapSection;
+ MCSection *StackMapSection = nullptr;
/// FaultMap section.
- MCSection *FaultMapSection;
+ MCSection *FaultMapSection = nullptr;
/// Remarks section.
- MCSection *RemarksSection;
+ MCSection *RemarksSection = nullptr;
/// EH frame section.
///
/// It is initialized on demand so it can be overwritten (with uniquing).
- MCSection *EHFrameSection;
+ MCSection *EHFrameSection = nullptr;
/// Section containing metadata on function stack sizes.
- MCSection *StackSizesSection;
- mutable DenseMap<const MCSymbol *, unsigned> StackSizesUniquing;
+ MCSection *StackSizesSection = nullptr;
+
+ /// Section for pseudo probe information used by AutoFDO
+ MCSection *PseudoProbeSection = nullptr;
+ MCSection *PseudoProbeDescSection = nullptr;
// ELF specific sections.
- MCSection *DataRelROSection;
- MCSection *MergeableConst4Section;
- MCSection *MergeableConst8Section;
- MCSection *MergeableConst16Section;
- MCSection *MergeableConst32Section;
+ MCSection *DataRelROSection = nullptr;
+ MCSection *MergeableConst4Section = nullptr;
+ MCSection *MergeableConst8Section = nullptr;
+ MCSection *MergeableConst16Section = nullptr;
+ MCSection *MergeableConst32Section = nullptr;
// MachO specific sections.
@@ -184,37 +191,44 @@
///
/// Contains the source code name of the variable, visibility and a pointer to
/// the initial value (.tdata or .tbss).
- MCSection *TLSTLVSection; // Defaults to ".tlv".
+ MCSection *TLSTLVSection = nullptr; // Defaults to ".tlv".
/// Section for thread local data initialization functions.
- const MCSection *TLSThreadInitSection; // Defaults to ".thread_init_func".
+ // Defaults to ".thread_init_func".
+ const MCSection *TLSThreadInitSection = nullptr;
- MCSection *CStringSection;
- MCSection *UStringSection;
- MCSection *TextCoalSection;
- MCSection *ConstTextCoalSection;
- MCSection *ConstDataSection;
- MCSection *DataCoalSection;
- MCSection *ConstDataCoalSection;
- MCSection *DataCommonSection;
- MCSection *DataBSSSection;
- MCSection *FourByteConstantSection;
- MCSection *EightByteConstantSection;
- MCSection *SixteenByteConstantSection;
- MCSection *LazySymbolPointerSection;
- MCSection *NonLazySymbolPointerSection;
- MCSection *ThreadLocalPointerSection;
+ MCSection *CStringSection = nullptr;
+ MCSection *UStringSection = nullptr;
+ MCSection *TextCoalSection = nullptr;
+ MCSection *ConstTextCoalSection = nullptr;
+ MCSection *ConstDataSection = nullptr;
+ MCSection *DataCoalSection = nullptr;
+ MCSection *ConstDataCoalSection = nullptr;
+ MCSection *DataCommonSection = nullptr;
+ MCSection *DataBSSSection = nullptr;
+ MCSection *FourByteConstantSection = nullptr;
+ MCSection *EightByteConstantSection = nullptr;
+ MCSection *SixteenByteConstantSection = nullptr;
+ MCSection *LazySymbolPointerSection = nullptr;
+ MCSection *NonLazySymbolPointerSection = nullptr;
+ MCSection *ThreadLocalPointerSection = nullptr;
/// COFF specific sections.
- MCSection *DrectveSection;
- MCSection *PDataSection;
- MCSection *XDataSection;
- MCSection *SXDataSection;
- MCSection *GFIDsSection;
+ MCSection *DrectveSection = nullptr;
+ MCSection *PDataSection = nullptr;
+ MCSection *XDataSection = nullptr;
+ MCSection *SXDataSection = nullptr;
+ MCSection *GFIDsSection = nullptr;
+ MCSection *GIATsSection = nullptr;
+ MCSection *GLJMPSection = nullptr;
+
+ // XCOFF specific sections
+ MCSection *TOCBaseSection = nullptr;
public:
void InitMCObjectFileInfo(const Triple &TT, bool PIC, MCContext &ctx,
bool LargeCodeModel = false);
+ MCContext &getContext() const { return *Ctx; }
bool getSupportsWeakOmittedEHFrame() const {
return SupportsWeakOmittedEHFrame;
@@ -240,7 +254,6 @@
MCSection *getDataSection() const { return DataSection; }
MCSection *getBSSSection() const { return BSSSection; }
MCSection *getReadOnlySection() const { return ReadOnlySection; }
- MCSection *getLSDASection() const { return LSDASection; }
MCSection *getCompactUnwindSection() const { return CompactUnwindSection; }
MCSection *getDwarfAbbrevSection() const { return DwarfAbbrevSection; }
MCSection *getDwarfInfoSection() const { return DwarfInfoSection; }
@@ -268,6 +281,7 @@
MCSection *getDwarfRnglistsSection() const { return DwarfRnglistsSection; }
MCSection *getDwarfLoclistsSection() const { return DwarfLoclistsSection; }
MCSection *getDwarfMacinfoSection() const { return DwarfMacinfoSection; }
+ MCSection *getDwarfMacroSection() const { return DwarfMacroSection; }
MCSection *getDwarfDebugNamesSection() const {
return DwarfDebugNamesSection;
@@ -297,6 +311,13 @@
MCSection *getDwarfRnglistsDWOSection() const {
return DwarfRnglistsDWOSection;
}
+ MCSection *getDwarfLoclistsDWOSection() const {
+ return DwarfLoclistsDWOSection;
+ }
+ MCSection *getDwarfMacroDWOSection() const { return DwarfMacroDWOSection; }
+ MCSection *getDwarfMacinfoDWOSection() const {
+ return DwarfMacinfoDWOSection;
+ }
MCSection *getDwarfCUIndexSection() const { return DwarfCUIndexSection; }
MCSection *getDwarfTUIndexSection() const { return DwarfTUIndexSection; }
MCSection *getDwarfSwiftASTSection() const { return DwarfSwiftASTSection; }
@@ -321,6 +342,12 @@
MCSection *getStackSizesSection(const MCSection &TextSec) const;
+ MCSection *getBBAddrMapSection(const MCSection &TextSec) const;
+
+ MCSection *getPseudoProbeSection(const MCSection *TextSec) const;
+
+ MCSection *getPseudoProbeDescSection(StringRef FuncName) const;
+
// ELF specific sections.
MCSection *getDataRelROSection() const { return DataRelROSection; }
const MCSection *getMergeableConst4Section() const {
@@ -379,10 +406,13 @@
MCSection *getXDataSection() const { return XDataSection; }
MCSection *getSXDataSection() const { return SXDataSection; }
MCSection *getGFIDsSection() const { return GFIDsSection; }
+ MCSection *getGIATsSection() const { return GIATsSection; }
+ MCSection *getGLJMPSection() const { return GLJMPSection; }
- MCSection *getEHFrameSection() {
- return EHFrameSection;
- }
+ // XCOFF specific sections
+ MCSection *getTOCBaseSection() const { return TOCBaseSection; }
+
+ MCSection *getEHFrameSection() const { return EHFrameSection; }
enum Environment { IsMachO, IsELF, IsCOFF, IsWasm, IsXCOFF };
Environment getObjectFileType() const { return Env; }
@@ -391,8 +421,8 @@
private:
Environment Env;
- bool PositionIndependent;
- MCContext *Ctx;
+ bool PositionIndependent = false;
+ MCContext *Ctx = nullptr;
Triple TT;
VersionTuple SDKVersion;
diff --git a/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h b/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h
index 8affca4..a00000b 100644
--- a/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCObjectStreamer.h
@@ -9,6 +9,7 @@
#ifndef LLVM_MC_MCOBJECTSTREAMER_H
#define LLVM_MC_MCOBJECTSTREAMER_H
+#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCSection.h"
@@ -38,6 +39,8 @@
bool EmitEHFrame;
bool EmitDebugFrame;
SmallVector<MCSymbol *, 2> PendingLabels;
+ SmallSetVector<MCSection *, 4> PendingLabelSections;
+ unsigned CurSubsectionIdx;
struct PendingMCFixup {
const MCSymbol *Sym;
MCFixup Fixup;
@@ -47,11 +50,11 @@
};
SmallVector<PendingMCFixup, 2> PendingFixups;
- virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
- void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
- void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
- MCSymbol *EmitCFILabel() override;
- void EmitInstructionImpl(const MCInst &Inst, const MCSubtargetInfo &STI);
+ virtual void emitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
+ void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
+ void emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
+ MCSymbol *emitCFILabel() override;
+ void emitInstructionImpl(const MCInst &Inst, const MCSubtargetInfo &STI);
void resolvePendingFixups();
protected:
@@ -67,8 +70,8 @@
/// Object streamers require the integrated assembler.
bool isIntegratedAssemblerRequired() const override { return true; }
- void EmitFrames(MCAsmBackend *MAB);
- void EmitCFISections(bool EH, bool Debug) override;
+ void emitFrames(MCAsmBackend *MAB);
+ void emitCFISections(bool EH, bool Debug) override;
MCFragment *getCurrentFragment() const;
@@ -84,103 +87,106 @@
/// Optionally a \p STI can be passed in so that a new fragment is created
/// if the Subtarget differs from the current fragment.
MCDataFragment *getOrCreateDataFragment(const MCSubtargetInfo* STI = nullptr);
- MCPaddingFragment *getOrCreatePaddingFragment();
protected:
bool changeSectionImpl(MCSection *Section, const MCExpr *Subsection);
- /// If any labels have been emitted but not assigned fragments, ensure that
- /// they get assigned, either to F if possible or to a new data fragment.
- /// Optionally, it is also possible to provide an offset \p FOffset, which
- /// will be used as a symbol offset within the fragment.
+ /// Assign a label to the current Section and Subsection even though a
+ /// fragment is not yet present. Use flushPendingLabels(F) to associate
+ /// a fragment with this label.
+ void addPendingLabel(MCSymbol* label);
+
+ /// If any labels have been emitted but not assigned fragments in the current
+ /// Section and Subsection, ensure that they get assigned, either to fragment
+ /// F if possible or to a new data fragment. Optionally, one can provide an
+ /// offset \p FOffset as a symbol offset within the fragment.
void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0);
public:
void visitUsedSymbol(const MCSymbol &Sym) override;
- /// Create a dummy fragment to assign any pending labels.
- void flushPendingLabels() { flushPendingLabels(nullptr); }
+ /// Create a data fragment for any pending labels across all Sections
+ /// and Subsections.
+ void flushPendingLabels();
MCAssembler &getAssembler() { return *Assembler; }
MCAssembler *getAssemblerPtr() override;
/// \name MCStreamer Interface
/// @{
- void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
- virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F);
- void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
- void EmitValueImpl(const MCExpr *Value, unsigned Size,
+ void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+ virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F,
+ uint64_t Offset);
+ void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
+ void emitValueImpl(const MCExpr *Value, unsigned Size,
SMLoc Loc = SMLoc()) override;
- void EmitULEB128Value(const MCExpr *Value) override;
- void EmitSLEB128Value(const MCExpr *Value) override;
- void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
- void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
- void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+ void emitULEB128Value(const MCExpr *Value) override;
+ void emitSLEB128Value(const MCExpr *Value) override;
+ void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+ void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+ void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
/// Emit an instruction to a special fragment, because this instruction
/// can change its size during relaxation.
- virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
+ virtual void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
- void EmitBundleAlignMode(unsigned AlignPow2) override;
- void EmitBundleLock(bool AlignToEnd) override;
- void EmitBundleUnlock() override;
- void EmitBytes(StringRef Data) override;
- void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
+ void emitBundleAlignMode(unsigned AlignPow2) override;
+ void emitBundleLock(bool AlignToEnd) override;
+ void emitBundleUnlock() override;
+ void emitBytes(StringRef Data) override;
+ void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
unsigned ValueSize = 1,
unsigned MaxBytesToEmit = 0) override;
- void EmitCodeAlignment(unsigned ByteAlignment,
+ void emitCodeAlignment(unsigned ByteAlignment,
unsigned MaxBytesToEmit = 0) override;
void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
SMLoc Loc) override;
- void
- EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) override;
- void
- EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) override;
- void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
- unsigned Column, unsigned Flags,
- unsigned Isa, unsigned Discriminator,
+ void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column,
+ unsigned Flags, unsigned Isa,
+ unsigned Discriminator,
StringRef FileName) override;
- void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
- const MCSymbol *Label,
- unsigned PointerSize);
- void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
+ void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
+ const MCSymbol *Label, unsigned PointerSize);
+ void emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
const MCSymbol *Label);
- void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
+ void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
unsigned Column, bool PrologueEnd, bool IsStmt,
StringRef FileName, SMLoc Loc) override;
- void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
+ void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
const MCSymbol *End) override;
- void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
+ void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
unsigned SourceFileId,
unsigned SourceLineNum,
const MCSymbol *FnStartSym,
const MCSymbol *FnEndSym) override;
- void EmitCVDefRangeDirective(
+ void emitCVDefRangeDirective(
ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
StringRef FixedSizePortion) override;
- void EmitCVStringTableDirective() override;
- void EmitCVFileChecksumsDirective() override;
- void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override;
- void EmitDTPRel32Value(const MCExpr *Value) override;
- void EmitDTPRel64Value(const MCExpr *Value) override;
- void EmitTPRel32Value(const MCExpr *Value) override;
- void EmitTPRel64Value(const MCExpr *Value) override;
- void EmitGPRel32Value(const MCExpr *Value) override;
- void EmitGPRel64Value(const MCExpr *Value) override;
- bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
- const MCExpr *Expr, SMLoc Loc,
- const MCSubtargetInfo &STI) override;
+ void emitCVStringTableDirective() override;
+ void emitCVFileChecksumsDirective() override;
+ void emitCVFileChecksumOffsetDirective(unsigned FileNo) override;
+ void emitDTPRel32Value(const MCExpr *Value) override;
+ void emitDTPRel64Value(const MCExpr *Value) override;
+ void emitTPRel32Value(const MCExpr *Value) override;
+ void emitTPRel64Value(const MCExpr *Value) override;
+ void emitGPRel32Value(const MCExpr *Value) override;
+ void emitGPRel64Value(const MCExpr *Value) override;
+ Optional<std::pair<bool, std::string>>
+ emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr,
+ SMLoc Loc, const MCSubtargetInfo &STI) override;
using MCStreamer::emitFill;
void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
SMLoc Loc = SMLoc()) override;
void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
SMLoc Loc = SMLoc()) override;
- void EmitFileDirective(StringRef Filename) override;
+ void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
+ SMLoc Loc) override;
+ void emitFileDirective(StringRef Filename) override;
- void EmitAddrsig() override;
- void EmitAddrsigSym(const MCSymbol *Sym) override;
+ void emitAddrsig() override;
+ void emitAddrsigSym(const MCSymbol *Sym) override;
- void FinishImpl() override;
+ void finishImpl() override;
/// Emit the absolute difference between two symbols if possible.
///
diff --git a/linux-x64/clang/include/llvm/MC/MCObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCObjectWriter.h
index 2547b2b..ddc2301 100644
--- a/linux-x64/clang/include/llvm/MC/MCObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCObjectWriter.h
@@ -9,13 +9,7 @@
#ifndef LLVM_MC_MCOBJECTWRITER_H
#define LLVM_MC_MCOBJECTWRITER_H
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
-#include "llvm/Support/Endian.h"
-#include "llvm/Support/EndianStream.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cassert>
#include <cstdint>
namespace llvm {
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h b/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h
index ea21550..44edd2b 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/AsmCond.h
@@ -30,8 +30,6 @@
ConditionalAssemblyType TheCond = NoCond;
bool CondMet = false;
bool Ignore = false;
-
- AsmCond() = default;
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h b/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h
index b729449..e187a28 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/AsmLexer.h
@@ -30,6 +30,7 @@
bool IsAtStartOfLine = true;
bool IsAtStartOfStatement = true;
bool IsPeeking = false;
+ bool EndStatementAtEOF = true;
protected:
/// LexToken - Read the next token and return its code.
@@ -41,7 +42,8 @@
AsmLexer &operator=(const AsmLexer &) = delete;
~AsmLexer() override;
- void setBuffer(StringRef Buf, const char *ptr = nullptr);
+ void setBuffer(StringRef Buf, const char *ptr = nullptr,
+ bool EndStatementAtEOF = true);
StringRef LexUntilEndOfStatement() override;
@@ -54,6 +56,7 @@
bool isAtStartOfComment(const char *Ptr);
bool isAtStatementSeparator(const char *Ptr);
int getNextChar();
+ int peekNextChar();
AsmToken ReturnError(const char *Loc, const std::string &Msg);
AsmToken LexIdentifier();
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h
index e89abea..21966d1 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmLexer.h
@@ -49,7 +49,11 @@
bool SkipSpace = true;
bool AllowAtInIdentifier;
bool IsAtStartOfStatement = true;
+ bool LexMasmHexFloats = false;
bool LexMasmIntegers = false;
+ bool LexMasmStrings = false;
+ bool UseMasmDefaultRadix = false;
+ unsigned DefaultRadix = 10;
AsmCommentConsumer *CommentConsumer = nullptr;
MCAsmLexer();
@@ -147,9 +151,23 @@
this->CommentConsumer = CommentConsumer;
}
- /// Set whether to lex masm-style binary and hex literals. They look like
- /// 0b1101 and 0ABCh respectively.
+ /// Set whether to lex masm-style binary (e.g., 0b1101) and radix-specified
+ /// literals (e.g., 0ABCh [hex], 576t [decimal], 77o [octal], 1101y [binary]).
void setLexMasmIntegers(bool V) { LexMasmIntegers = V; }
+
+ /// Set whether to use masm-style default-radix integer literals. If disabled,
+ /// assume decimal unless prefixed (e.g., 0x2c [hex], 077 [octal]).
+ void useMasmDefaultRadix(bool V) { UseMasmDefaultRadix = V; }
+
+ unsigned getMasmDefaultRadix() const { return DefaultRadix; }
+ void setMasmDefaultRadix(unsigned Radix) { DefaultRadix = Radix; }
+
+ /// Set whether to lex masm-style hex float literals, such as 3f800000r.
+ void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; }
+
+ /// Set whether to lex masm-style string literals, such as 'Can''t find file'
+ /// and "This ""value"" not found".
+ void setLexMasmStrings(bool V) { LexMasmStrings = V; }
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h
index da5653e..391a6b0 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParser.h
@@ -90,6 +90,20 @@
IdKind Kind;
};
+// Generic type information for an assembly object.
+// All sizes measured in bytes.
+struct AsmTypeInfo {
+ StringRef Name;
+ unsigned Size = 0;
+ unsigned ElementSize = 0;
+ unsigned Length = 0;
+};
+
+struct AsmFieldInfo {
+ AsmTypeInfo Type;
+ unsigned Offset = 0;
+};
+
/// Generic Sema callback for assembly parser.
class MCAsmParserSemaCallback {
public:
@@ -165,8 +179,24 @@
/// Run the parser on the input source buffer.
virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
- virtual void setParsingInlineAsm(bool V) = 0;
- virtual bool isParsingInlineAsm() = 0;
+ virtual void setParsingMSInlineAsm(bool V) = 0;
+ virtual bool isParsingMSInlineAsm() = 0;
+
+ virtual bool isParsingMasm() const { return false; }
+
+ virtual bool defineMacro(StringRef Name, StringRef Value) { return true; }
+
+ virtual bool lookUpField(StringRef Name, AsmFieldInfo &Info) const {
+ return true;
+ }
+ virtual bool lookUpField(StringRef Base, StringRef Member,
+ AsmFieldInfo &Info) const {
+ return true;
+ }
+
+ virtual bool lookUpType(StringRef Name, AsmTypeInfo &Info) const {
+ return true;
+ }
/// Parse MS-style inline assembly.
virtual bool parseMSInlineAsm(
@@ -250,6 +280,10 @@
/// characters and return the string contents.
virtual bool parseEscapedString(std::string &Data) = 0;
+ /// Parse an angle-bracket delimited string at the current position if one is
+ /// present, returning the string contents.
+ virtual bool parseAngleBracketString(std::string &Data) = 0;
+
/// Skip to the end of the current statement, for error recovery.
virtual void eatToEndOfStatement() = 0;
@@ -266,7 +300,8 @@
/// \param Res - The value of the expression. The result is undefined
/// on error.
/// \return - False on success.
- virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) = 0;
+ virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
+ AsmTypeInfo *TypeInfo) = 0;
/// Parse an arbitrary expression, assuming that an initial '(' has
/// already been consumed.
@@ -300,10 +335,14 @@
SMLoc &EndLoc) = 0;
};
-/// Create an MCAsmParser instance.
+/// Create an MCAsmParser instance for parsing assembly similar to gas syntax
MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &,
const MCAsmInfo &, unsigned CB = 0);
+/// Create an MCAsmParser instance for parsing Microsoft MASM-style assembly
+MCAsmParser *createMCMasmParser(SourceMgr &, MCContext &, MCStreamer &,
+ const MCAsmInfo &, unsigned CB = 0);
+
} // end namespace llvm
#endif // LLVM_MC_MCPARSER_MCASMPARSER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h
index 5d2afe8..c37889c 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCAsmParserExtension.h
@@ -98,6 +98,8 @@
return getParser().parseOptionalToken(T);
}
+ bool ParseDirectiveCGProfile(StringRef, SMLoc);
+
bool check(bool P, const Twine &Msg) {
return getParser().check(P, Msg);
}
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h b/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h
index 2b6e2aa..abb9562 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCParsedAsmOperand.h
@@ -71,10 +71,10 @@
/// variable/label? Only valid when parsing MS-style inline assembly.
virtual bool needAddressOf() const { return false; }
- /// isOffsetOf - Do we need to emit code to get the offset of the variable,
- /// rather then the value of the variable? Only valid when parsing MS-style
- /// inline assembly.
- virtual bool isOffsetOf() const { return false; }
+ /// isOffsetOfLocal - Do we need to emit code to get the offset of the local
+ /// variable, rather than its value? Only valid when parsing MS-style inline
+ /// assembly.
+ virtual bool isOffsetOfLocal() const { return false; }
/// getOffsetOfLoc - Get the location of the offset operator.
virtual SMLoc getOffsetOfLoc() const { return SMLoc(); }
diff --git a/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h b/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h
index 849dbd5..0a1e50d 100644
--- a/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h
+++ b/linux-x64/clang/include/llvm/MC/MCParser/MCTargetAsmParser.h
@@ -24,7 +24,6 @@
namespace llvm {
class MCInst;
-class MCParsedAsmOperand;
class MCStreamer;
class MCSubtargetInfo;
template <typename T> class SmallVectorImpl;
@@ -35,6 +34,7 @@
AOK_Align, // Rewrite align as .align.
AOK_EVEN, // Rewrite even as .even.
AOK_Emit, // Rewrite _emit as .byte.
+ AOK_CallInput, // Rewrite in terms of ${N:P}.
AOK_Input, // Rewrite in terms of $N.
AOK_Output, // Rewrite in terms of $N.
AOK_SizeDirective, // Add a sizing directive (e.g., dword ptr).
@@ -49,6 +49,7 @@
2, // AOK_EVEN
2, // AOK_Emit
3, // AOK_Input
+ 3, // AOK_CallInput
3, // AOK_Output
5, // AOK_SizeDirective
1, // AOK_Label
@@ -64,39 +65,27 @@
int64_t Imm;
StringRef BaseReg;
StringRef IndexReg;
+ StringRef OffsetName;
unsigned Scale;
- IntelExpr(bool needBracs = false) : NeedBracs(needBracs), Imm(0),
- BaseReg(StringRef()), IndexReg(StringRef()),
- Scale(1) {}
- // Compund immediate expression
- IntelExpr(int64_t imm, bool needBracs) : IntelExpr(needBracs) {
- Imm = imm;
- }
- // [Reg + ImmediateExpression]
- // We don't bother to emit an immediate expression evaluated to zero
- IntelExpr(StringRef reg, int64_t imm = 0, unsigned scale = 0,
- bool needBracs = true) :
- IntelExpr(imm, needBracs) {
- IndexReg = reg;
+ IntelExpr()
+ : NeedBracs(false), Imm(0), BaseReg(StringRef()), IndexReg(StringRef()),
+ OffsetName(StringRef()), Scale(1) {}
+ // [BaseReg + IndexReg * ScaleExpression + OFFSET name + ImmediateExpression]
+ IntelExpr(StringRef baseReg, StringRef indexReg, unsigned scale,
+ StringRef offsetName, int64_t imm, bool needBracs)
+ : NeedBracs(needBracs), Imm(imm), BaseReg(baseReg), IndexReg(indexReg),
+ OffsetName(offsetName), Scale(1) {
if (scale)
Scale = scale;
}
- // [BaseReg + IndexReg * ScaleExpression + ImmediateExpression]
- IntelExpr(StringRef baseReg, StringRef indexReg, unsigned scale = 0,
- int64_t imm = 0, bool needBracs = true) :
- IntelExpr(indexReg, imm, scale, needBracs) {
- BaseReg = baseReg;
- }
- bool hasBaseReg() const {
- return BaseReg.size();
- }
- bool hasIndexReg() const {
- return IndexReg.size();
- }
- bool hasRegs() const {
- return hasBaseReg() || hasIndexReg();
- }
+ bool hasBaseReg() const { return !BaseReg.empty(); }
+ bool hasIndexReg() const { return !IndexReg.empty(); }
+ bool hasRegs() const { return hasBaseReg() || hasIndexReg(); }
+ bool hasOffset() const { return !OffsetName.empty(); }
+ // Normally we won't emit immediates unconditionally,
+ // unless we've got no other components
+ bool emitImm() const { return !(hasRegs() || hasOffset()); }
bool isValid() const {
return (Scale == 1) ||
(hasIndexReg() && (Scale == 2 || Scale == 4 || Scale == 8));
@@ -107,13 +96,14 @@
AsmRewriteKind Kind;
SMLoc Loc;
unsigned Len;
+ bool Done;
int64_t Val;
StringRef Label;
IntelExpr IntelExp;
public:
AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len = 0, int64_t val = 0)
- : Kind(kind), Loc(loc), Len(len), Val(val) {}
+ : Kind(kind), Loc(loc), Len(len), Done(false), Val(val) {}
AsmRewrite(AsmRewriteKind kind, SMLoc loc, unsigned len, StringRef label)
: AsmRewrite(kind, loc, len) { Label = label; }
AsmRewrite(SMLoc loc, unsigned len, IntelExpr exp)
@@ -174,6 +164,7 @@
: DiagnosticPredicateTy::NearMatch) {}
DiagnosticPredicate(DiagnosticPredicateTy T) : Type(T) {}
DiagnosticPredicate(const DiagnosticPredicate &) = default;
+ DiagnosticPredicate& operator=(const DiagnosticPredicate &) = default;
operator bool() const { return Type == DiagnosticPredicateTy::Match; }
bool isMatch() const { return Type == DiagnosticPredicateTy::Match; }
@@ -337,12 +328,12 @@
/// AvailableFeatures - The current set of available features.
FeatureBitset AvailableFeatures;
- /// ParsingInlineAsm - Are we parsing ms-style inline assembly?
- bool ParsingInlineAsm = false;
+ /// ParsingMSInlineAsm - Are we parsing ms-style inline assembly?
+ bool ParsingMSInlineAsm = false;
/// SemaCallback - The Sema callback implementation. Must be set when parsing
/// ms-style inline assembly.
- MCAsmParserSemaCallback *SemaCallback;
+ MCAsmParserSemaCallback *SemaCallback = nullptr;
/// Set of options which affects instrumentation of inline assembly.
MCTargetOptions MCOptions;
@@ -367,8 +358,8 @@
AvailableFeatures = Value;
}
- bool isParsingInlineAsm () { return ParsingInlineAsm; }
- void setParsingInlineAsm (bool Value) { ParsingInlineAsm = Value; }
+ bool isParsingMSInlineAsm () { return ParsingMSInlineAsm; }
+ void setParsingMSInlineAsm (bool Value) { ParsingMSInlineAsm = Value; }
MCTargetOptions getTargetOptions() const { return MCOptions; }
@@ -378,12 +369,20 @@
// Target-specific parsing of expression.
virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
- return getParser().parsePrimaryExpr(Res, EndLoc);
+ return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
}
virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
SMLoc &EndLoc) = 0;
+ /// tryParseRegister - parse one register if possible
+ ///
+ /// Check whether a register specification can be parsed at the current
+ /// location, without failing the entire parse if it can't. Must not consume
+ /// tokens if the parse fails.
+ virtual OperandMatchResultTy
+ tryParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) = 0;
+
/// ParseInstruction - Parse one assembly instruction.
///
/// The parser is positioned following the instruction name. The target
diff --git a/linux-x64/clang/include/llvm/MC/MCPseudoProbe.h b/linux-x64/clang/include/llvm/MC/MCPseudoProbe.h
new file mode 100644
index 0000000..b9a6196
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MC/MCPseudoProbe.h
@@ -0,0 +1,178 @@
+//===- MCPseudoProbe.h - Pseudo probe encoding support ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the declaration of the MCPseudoProbe to support the pseudo
+// probe encoding for AutoFDO. Pseudo probes together with their inline context
+// are encoded in a DFS recursive way in the .pseudoprobe sections. For each
+// .pseudoprobe section, the encoded binary data consist of a single or mutiple
+// function records each for one outlined function. A function record has the
+// following format :
+//
+// FUNCTION BODY (one for each outlined function present in the text section)
+// GUID (uint64)
+// GUID of the function
+// NPROBES (ULEB128)
+// Number of probes originating from this function.
+// NUM_INLINED_FUNCTIONS (ULEB128)
+// Number of callees inlined into this function, aka number of
+// first-level inlinees
+// PROBE RECORDS
+// A list of NPROBES entries. Each entry contains:
+// INDEX (ULEB128)
+// TYPE (uint4)
+// 0 - block probe, 1 - indirect call, 2 - direct call
+// ATTRIBUTE (uint3)
+// reserved
+// ADDRESS_TYPE (uint1)
+// 0 - code address, 1 - address delta
+// CODE_ADDRESS (uint64 or ULEB128)
+// code address or address delta, depending on ADDRESS_TYPE
+// INLINED FUNCTION RECORDS
+// A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
+// callees. Each record contains:
+// INLINE SITE
+// GUID of the inlinee (uint64)
+// ID of the callsite probe (ULEB128)
+// FUNCTION BODY
+// A FUNCTION BODY entry describing the inlined function.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCPSEUDOPROBE_H
+#define LLVM_MC_MCPSEUDOPROBE_H
+
+#include "llvm/ADT/MapVector.h"
+#include "llvm/MC/MCSection.h"
+#include <functional>
+#include <map>
+#include <vector>
+
+namespace llvm {
+
+class MCStreamer;
+class MCSymbol;
+class MCObjectStreamer;
+
+enum class MCPseudoProbeFlag {
+ // If set, indicates that the probe is encoded as an address delta
+ // instead of a real code address.
+ AddressDelta = 0x1,
+};
+
+/// Instances of this class represent a pseudo probe instance for a pseudo probe
+/// table entry, which is created during a machine instruction is assembled and
+/// uses an address from a temporary label created at the current address in the
+/// current section.
+class MCPseudoProbe {
+ MCSymbol *Label;
+ uint64_t Guid;
+ uint64_t Index;
+ uint8_t Type;
+ uint8_t Attributes;
+
+public:
+ MCPseudoProbe(MCSymbol *Label, uint64_t Guid, uint64_t Index, uint64_t Type,
+ uint64_t Attributes)
+ : Label(Label), Guid(Guid), Index(Index), Type(Type),
+ Attributes(Attributes) {
+ assert(Type <= 0xFF && "Probe type too big to encode, exceeding 2^8");
+ assert(Attributes <= 0xFF &&
+ "Probe attributes too big to encode, exceeding 2^16");
+ }
+
+ MCSymbol *getLabel() const { return Label; }
+
+ uint64_t getGuid() const { return Guid; }
+
+ uint64_t getIndex() const { return Index; }
+
+ uint8_t getType() const { return Type; }
+
+ uint8_t getAttributes() const { return Attributes; }
+
+ void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *LastProbe) const;
+};
+
+// An inline frame has the form <Guid, ProbeID>
+using InlineSite = std::tuple<uint64_t, uint32_t>;
+using MCPseudoProbeInlineStack = SmallVector<InlineSite, 8>;
+
+// A Tri-tree based data structure to group probes by inline stack.
+// A tree is allocated for a standalone .text section. A fake
+// instance is created as the root of a tree.
+// A real instance of this class is created for each function, either an
+// unlined function that has code in .text section or an inlined function.
+class MCPseudoProbeInlineTree {
+ uint64_t Guid;
+ // Set of probes that come with the function.
+ std::vector<MCPseudoProbe> Probes;
+ // Use std::map for a deterministic output.
+ std::map<InlineSite, MCPseudoProbeInlineTree *> Inlinees;
+
+ // Root node has a GUID 0.
+ bool isRoot() { return Guid == 0; }
+ MCPseudoProbeInlineTree *getOrAddNode(InlineSite Site);
+
+public:
+ MCPseudoProbeInlineTree() = default;
+ MCPseudoProbeInlineTree(uint64_t Guid) : Guid(Guid) {}
+ ~MCPseudoProbeInlineTree();
+ void addPseudoProbe(const MCPseudoProbe &Probe,
+ const MCPseudoProbeInlineStack &InlineStack);
+ void emit(MCObjectStreamer *MCOS, const MCPseudoProbe *&LastProbe);
+};
+
+/// Instances of this class represent the pseudo probes inserted into a compile
+/// unit.
+class MCPseudoProbeSection {
+public:
+ void addPseudoProbe(MCSection *Sec, const MCPseudoProbe &Probe,
+ const MCPseudoProbeInlineStack &InlineStack) {
+ MCProbeDivisions[Sec].addPseudoProbe(Probe, InlineStack);
+ }
+
+ // TODO: Sort by getOrdinal to ensure a determinstic section order
+ using MCProbeDivisionMap = std::map<MCSection *, MCPseudoProbeInlineTree>;
+
+private:
+ // A collection of MCPseudoProbe for each text section. The MCPseudoProbes
+ // are grouped by GUID of the functions where they are from and will be
+ // encoded by groups. In the comdat scenario where a text section really only
+ // contains the code of a function solely, the probes associated with a comdat
+ // function are still grouped by GUIDs due to inlining that can bring probes
+ // from different functions into one function.
+ MCProbeDivisionMap MCProbeDivisions;
+
+public:
+ const MCProbeDivisionMap &getMCProbes() const { return MCProbeDivisions; }
+
+ bool empty() const { return MCProbeDivisions.empty(); }
+
+ void emit(MCObjectStreamer *MCOS);
+};
+
+class MCPseudoProbeTable {
+ // A collection of MCPseudoProbe in the current module grouped by text
+ // sections. MCPseudoProbes will be encoded into a corresponding
+ // .pseudoprobe section. With functions emitted as separate comdats,
+ // a text section really only contains the code of a function solely, and the
+ // probes associated with the text section will be emitted into a standalone
+ // .pseudoprobe section that shares the same comdat group with the function.
+ MCPseudoProbeSection MCProbeSections;
+
+public:
+ static void emit(MCObjectStreamer *MCOS);
+
+ MCPseudoProbeSection &getProbeSections() { return MCProbeSections; }
+
+#ifndef NDEBUG
+ static int DdgPrintIndent;
+#endif
+};
+} // end namespace llvm
+
+#endif // LLVM_MC_MCPSEUDOPROBE_H
diff --git a/linux-x64/clang/include/llvm/MC/MCRegister.h b/linux-x64/clang/include/llvm/MC/MCRegister.h
new file mode 100644
index 0000000..8bbeab5
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MC/MCRegister.h
@@ -0,0 +1,114 @@
+//===-- llvm/MC/Register.h --------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_REGISTER_H
+#define LLVM_MC_REGISTER_H
+
+#include "llvm/ADT/DenseMapInfo.h"
+#include <cassert>
+
+namespace llvm {
+
+/// An unsigned integer type large enough to represent all physical registers,
+/// but not necessarily virtual registers.
+using MCPhysReg = uint16_t;
+
+/// Wrapper class representing physical registers. Should be passed by value.
+class MCRegister {
+ friend hash_code hash_value(const MCRegister &);
+ unsigned Reg;
+
+public:
+ constexpr MCRegister(unsigned Val = 0): Reg(Val) {}
+
+ // Register numbers can represent physical registers, virtual registers, and
+ // sometimes stack slots. The unsigned values are divided into these ranges:
+ //
+ // 0 Not a register, can be used as a sentinel.
+ // [1;2^30) Physical registers assigned by TableGen.
+ // [2^30;2^31) Stack slots. (Rarely used.)
+ // [2^31;2^32) Virtual registers assigned by MachineRegisterInfo.
+ //
+ // Further sentinels can be allocated from the small negative integers.
+ // DenseMapInfo<unsigned> uses -1u and -2u.
+ static_assert(std::numeric_limits<decltype(Reg)>::max() >= 0xFFFFFFFF,
+ "Reg isn't large enough to hold full range.");
+ static constexpr unsigned NoRegister = 0u;
+ static constexpr unsigned FirstPhysicalReg = 1u;
+ static constexpr unsigned FirstStackSlot = 1u << 30;
+ static constexpr unsigned VirtualRegFlag = 1u << 31;
+
+ /// This is the portion of the positive number space that is not a physical
+ /// register. StackSlot values do not exist in the MC layer, see
+ /// Register::isStackSlot() for the more information on them.
+ ///
+ static bool isStackSlot(unsigned Reg) {
+ return FirstStackSlot <= Reg && Reg < VirtualRegFlag;
+ }
+
+ /// Return true if the specified register number is in
+ /// the physical register namespace.
+ static bool isPhysicalRegister(unsigned Reg) {
+ return FirstPhysicalReg <= Reg && Reg < FirstStackSlot;
+ }
+
+ constexpr operator unsigned() const {
+ return Reg;
+ }
+
+ /// Check the provided unsigned value is a valid MCRegister.
+ static MCRegister from(unsigned Val) {
+ assert(Val == NoRegister || isPhysicalRegister(Val));
+ return MCRegister(Val);
+ }
+
+ unsigned id() const {
+ return Reg;
+ }
+
+ bool isValid() const { return Reg != NoRegister; }
+
+ /// Comparisons between register objects
+ bool operator==(const MCRegister &Other) const { return Reg == Other.Reg; }
+ bool operator!=(const MCRegister &Other) const { return Reg != Other.Reg; }
+
+ /// Comparisons against register constants. E.g.
+ /// * R == AArch64::WZR
+ /// * R == 0
+ /// * R == VirtRegMap::NO_PHYS_REG
+ bool operator==(unsigned Other) const { return Reg == Other; }
+ bool operator!=(unsigned Other) const { return Reg != Other; }
+ bool operator==(int Other) const { return Reg == unsigned(Other); }
+ bool operator!=(int Other) const { return Reg != unsigned(Other); }
+ // MSVC requires that we explicitly declare these two as well.
+ bool operator==(MCPhysReg Other) const { return Reg == unsigned(Other); }
+ bool operator!=(MCPhysReg Other) const { return Reg != unsigned(Other); }
+};
+
+// Provide DenseMapInfo for MCRegister
+template<> struct DenseMapInfo<MCRegister> {
+ static inline unsigned getEmptyKey() {
+ return DenseMapInfo<unsigned>::getEmptyKey();
+ }
+ static inline unsigned getTombstoneKey() {
+ return DenseMapInfo<unsigned>::getTombstoneKey();
+ }
+ static unsigned getHashValue(const MCRegister &Val) {
+ return DenseMapInfo<unsigned>::getHashValue(Val.id());
+ }
+ static bool isEqual(const MCRegister &LHS, const MCRegister &RHS) {
+ return DenseMapInfo<unsigned>::isEqual(LHS.id(), RHS.id());
+ }
+};
+
+inline hash_code hash_value(const MCRegister &Reg) {
+ return hash_value(Reg.id());
+}
+}
+
+#endif // ifndef LLVM_MC_REGISTER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h b/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h
index 92d39c3..0c1ac62 100644
--- a/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCRegisterInfo.h
@@ -16,18 +16,17 @@
#define LLVM_MC_MCREGISTERINFO_H
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/iterator.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/MC/LaneBitmask.h"
+#include "llvm/MC/MCRegister.h"
#include <cassert>
#include <cstdint>
+#include <iterator>
#include <utility>
namespace llvm {
-/// An unsigned integer type large enough to represent all physical registers,
-/// but not necessarily virtual registers.
-using MCPhysReg = uint16_t;
-
/// MCRegisterClass - Base class of TargetRegisterClass.
class MCRegisterClass {
public:
@@ -65,16 +64,17 @@
/// contains - Return true if the specified register is included in this
/// register class. This does not include virtual registers.
- bool contains(unsigned Reg) const {
- unsigned InByte = Reg % 8;
- unsigned Byte = Reg / 8;
+ bool contains(MCRegister Reg) const {
+ unsigned RegNo = unsigned(Reg);
+ unsigned InByte = RegNo % 8;
+ unsigned Byte = RegNo / 8;
if (Byte >= RegSetSize)
return false;
return (RegSet[Byte] & (1 << InByte)) != 0;
}
/// contains - Return true if both registers are in this class.
- bool contains(unsigned Reg1, unsigned Reg2) const {
+ bool contains(MCRegister Reg1, MCRegister Reg2) const {
return contains(Reg1) && contains(Reg2);
}
@@ -148,8 +148,8 @@
private:
const MCRegisterDesc *Desc; // Pointer to the descriptor array
unsigned NumRegs; // Number of entries in the array
- unsigned RAReg; // Return address register
- unsigned PCReg; // Program counter register
+ MCRegister RAReg; // Return address register
+ MCRegister PCReg; // Program counter register
const MCRegisterClass *Classes; // Pointer to the regclass array
unsigned NumClasses; // Number of entries in the array
unsigned NumRegUnits; // Number of regunits.
@@ -175,10 +175,13 @@
const DwarfLLVMRegPair *EHL2DwarfRegs; // LLVM to Dwarf regs mapping EH
const DwarfLLVMRegPair *Dwarf2LRegs; // Dwarf to LLVM regs mapping
const DwarfLLVMRegPair *EHDwarf2LRegs; // Dwarf to LLVM regs mapping EH
- DenseMap<unsigned, int> L2SEHRegs; // LLVM to SEH regs mapping
- DenseMap<unsigned, int> L2CVRegs; // LLVM to CV regs mapping
+ DenseMap<MCRegister, int> L2SEHRegs; // LLVM to SEH regs mapping
+ DenseMap<MCRegister, int> L2CVRegs; // LLVM to CV regs mapping
public:
+ // Forward declaration to become a friend class of DiffListIterator.
+ template <class SubT> class mc_difflist_iterator;
+
/// DiffListIterator - Base iterator class that can traverse the
/// differentially encoded register and regunit lists in DiffLists.
/// Don't use this class directly, use one of the specialized sub-classes
@@ -202,7 +205,7 @@
/// advance - Move to the next list position, return the applied
/// differential. This function does not detect the end of the list, that
/// is the caller's responsibility (by checking for a 0 return value).
- unsigned advance() {
+ MCRegister advance() {
assert(isValid() && "Cannot move off the end of the list.");
MCPhysReg D = *List++;
Val += D;
@@ -214,7 +217,7 @@
bool isValid() const { return List; }
/// Dereference the iterator to get the value at the current position.
- unsigned operator*() const { return Val; }
+ MCRegister operator*() const { return Val; }
/// Pre-increment to move to the next position.
void operator++() {
@@ -222,8 +225,113 @@
if (!advance())
List = nullptr;
}
+
+ template <class SubT> friend class MCRegisterInfo::mc_difflist_iterator;
};
+ /// Forward iterator using DiffListIterator.
+ template <class SubT>
+ class mc_difflist_iterator
+ : public iterator_facade_base<mc_difflist_iterator<SubT>,
+ std::forward_iterator_tag, MCPhysReg> {
+ MCRegisterInfo::DiffListIterator Iter;
+ /// Current value as MCPhysReg, so we can return a reference to it.
+ MCPhysReg Val;
+
+ protected:
+ mc_difflist_iterator(MCRegisterInfo::DiffListIterator Iter) : Iter(Iter) {}
+
+ // Allow conversion between instantiations where valid.
+ mc_difflist_iterator(MCRegister Reg, const MCPhysReg *DiffList) {
+ Iter.init(Reg, DiffList);
+ Val = *Iter;
+ }
+
+ public:
+ // Allow default construction to build variables, but this doesn't build
+ // a useful iterator.
+ mc_difflist_iterator() = default;
+
+ /// Return an iterator past the last element.
+ static SubT end() {
+ SubT End;
+ End.Iter.List = nullptr;
+ return End;
+ }
+
+ bool operator==(const mc_difflist_iterator &Arg) const {
+ return Iter.List == Arg.Iter.List;
+ }
+
+ const MCPhysReg &operator*() const { return Val; }
+
+ using mc_difflist_iterator::iterator_facade_base::operator++;
+ void operator++() {
+ assert(Iter.List && "Cannot increment the end iterator!");
+ ++Iter;
+ Val = *Iter;
+ }
+ };
+
+ /// Forward iterator over all sub-registers.
+ /// TODO: Replace remaining uses of MCSubRegIterator.
+ class mc_subreg_iterator : public mc_difflist_iterator<mc_subreg_iterator> {
+ public:
+ mc_subreg_iterator(MCRegisterInfo::DiffListIterator Iter)
+ : mc_difflist_iterator(Iter) {}
+ mc_subreg_iterator() = default;
+ mc_subreg_iterator(MCRegister Reg, const MCRegisterInfo *MCRI)
+ : mc_difflist_iterator(Reg, MCRI->DiffLists + MCRI->get(Reg).SubRegs) {}
+ };
+
+ /// Forward iterator over all super-registers.
+ /// TODO: Replace remaining uses of MCSuperRegIterator.
+ class mc_superreg_iterator
+ : public mc_difflist_iterator<mc_superreg_iterator> {
+ public:
+ mc_superreg_iterator(MCRegisterInfo::DiffListIterator Iter)
+ : mc_difflist_iterator(Iter) {}
+ mc_superreg_iterator() = default;
+ mc_superreg_iterator(MCRegister Reg, const MCRegisterInfo *MCRI)
+ : mc_difflist_iterator(Reg,
+ MCRI->DiffLists + MCRI->get(Reg).SuperRegs) {}
+ };
+
+ /// Return an iterator range over all sub-registers of \p Reg, excluding \p
+ /// Reg.
+ iterator_range<mc_subreg_iterator> subregs(MCRegister Reg) const {
+ return make_range(std::next(mc_subreg_iterator(Reg, this)),
+ mc_subreg_iterator::end());
+ }
+
+ /// Return an iterator range over all sub-registers of \p Reg, including \p
+ /// Reg.
+ iterator_range<mc_subreg_iterator> subregs_inclusive(MCRegister Reg) const {
+ return make_range({Reg, this}, mc_subreg_iterator::end());
+ }
+
+ /// Return an iterator range over all super-registers of \p Reg, excluding \p
+ /// Reg.
+ iterator_range<mc_superreg_iterator> superregs(MCRegister Reg) const {
+ return make_range(std::next(mc_superreg_iterator(Reg, this)),
+ mc_superreg_iterator::end());
+ }
+
+ /// Return an iterator range over all super-registers of \p Reg, including \p
+ /// Reg.
+ iterator_range<mc_superreg_iterator>
+ superregs_inclusive(MCRegister Reg) const {
+ return make_range({Reg, this}, mc_superreg_iterator::end());
+ }
+
+ /// Return an iterator range over all sub- and super-registers of \p Reg,
+ /// including \p Reg.
+ detail::concat_range<const MCPhysReg, iterator_range<mc_subreg_iterator>,
+ iterator_range<mc_superreg_iterator>>
+ sub_and_superregs_inclusive(MCRegister Reg) const {
+ return concat<const MCPhysReg>(subregs_inclusive(Reg), superregs(Reg));
+ }
+
// These iterators are allowed to sub-class DiffListIterator and access
// internal list pointers.
friend class MCSubRegIterator;
@@ -309,26 +417,26 @@
/// as the LLVM register number.
/// FIXME: TableGen these numbers. Currently this requires target specific
/// initialization code.
- void mapLLVMRegToSEHReg(unsigned LLVMReg, int SEHReg) {
+ void mapLLVMRegToSEHReg(MCRegister LLVMReg, int SEHReg) {
L2SEHRegs[LLVMReg] = SEHReg;
}
- void mapLLVMRegToCVReg(unsigned LLVMReg, int CVReg) {
+ void mapLLVMRegToCVReg(MCRegister LLVMReg, int CVReg) {
L2CVRegs[LLVMReg] = CVReg;
}
/// This method should return the register where the return
/// address can be found.
- unsigned getRARegister() const {
+ MCRegister getRARegister() const {
return RAReg;
}
/// Return the register which is the program counter.
- unsigned getProgramCounter() const {
+ MCRegister getProgramCounter() const {
return PCReg;
}
- const MCRegisterDesc &operator[](unsigned RegNo) const {
+ const MCRegisterDesc &operator[](MCRegister RegNo) const {
assert(RegNo < NumRegs &&
"Attempting to access record for invalid register number!");
return Desc[RegNo];
@@ -336,24 +444,24 @@
/// Provide a get method, equivalent to [], but more useful with a
/// pointer to this object.
- const MCRegisterDesc &get(unsigned RegNo) const {
+ const MCRegisterDesc &get(MCRegister RegNo) const {
return operator[](RegNo);
}
/// Returns the physical register number of sub-register "Index"
/// for physical register RegNo. Return zero if the sub-register does not
/// exist.
- unsigned getSubReg(unsigned Reg, unsigned Idx) const;
+ MCRegister getSubReg(MCRegister Reg, unsigned Idx) const;
/// Return a super-register of the specified register
/// Reg so its sub-register of index SubIdx is Reg.
- unsigned getMatchingSuperReg(unsigned Reg, unsigned SubIdx,
- const MCRegisterClass *RC) const;
+ MCRegister getMatchingSuperReg(MCRegister Reg, unsigned SubIdx,
+ const MCRegisterClass *RC) const;
/// For a given register pair, return the sub-register index
/// if the second register is a sub-register of the first. Return zero
/// otherwise.
- unsigned getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const;
+ unsigned getSubRegIndex(MCRegister RegNo, MCRegister SubRegNo) const;
/// Get the size of the bit range covered by a sub-register index.
/// If the index isn't continuous, return the sum of the sizes of its parts.
@@ -367,7 +475,7 @@
/// Return the human-readable symbolic target-specific name for the
/// specified physical register.
- const char *getName(unsigned RegNo) const {
+ const char *getName(MCRegister RegNo) const {
return RegStrings + get(RegNo).Name;
}
@@ -395,15 +503,11 @@
/// number. Returns -1 if there is no equivalent value. The second
/// parameter allows targets to use different numberings for EH info and
/// debugging info.
- int getDwarfRegNum(unsigned RegNum, bool isEH) const;
+ int getDwarfRegNum(MCRegister RegNum, bool isEH) const;
- /// Map a dwarf register back to a target register.
- int getLLVMRegNum(unsigned RegNum, bool isEH) const;
-
- /// Map a DWARF EH register back to a target register (same as
- /// getLLVMRegNum(RegNum, true)) but return -1 if there is no mapping,
- /// rather than asserting that there must be one.
- int getLLVMRegNumFromEH(unsigned RegNum) const;
+ /// Map a dwarf register back to a target register. Returns None is there is
+ /// no mapping.
+ Optional<unsigned> getLLVMRegNum(unsigned RegNum, bool isEH) const;
/// Map a target EH register number to an equivalent DWARF register
/// number.
@@ -411,11 +515,11 @@
/// Map a target register to an equivalent SEH register
/// number. Returns LLVM register number if there is no equivalent value.
- int getSEHRegNum(unsigned RegNum) const;
+ int getSEHRegNum(MCRegister RegNum) const;
/// Map a target register to an equivalent CodeView register
/// number.
- int getCodeViewRegNum(unsigned RegNum) const;
+ int getCodeViewRegNum(MCRegister RegNum) const;
regclass_iterator regclass_begin() const { return Classes; }
regclass_iterator regclass_end() const { return Classes+NumClasses; }
@@ -439,34 +543,34 @@
}
/// Returns the encoding for RegNo
- uint16_t getEncodingValue(unsigned RegNo) const {
+ uint16_t getEncodingValue(MCRegister RegNo) const {
assert(RegNo < NumRegs &&
"Attempting to get encoding for invalid register number!");
return RegEncodingTable[RegNo];
}
/// Returns true if RegB is a sub-register of RegA.
- bool isSubRegister(unsigned RegA, unsigned RegB) const {
+ bool isSubRegister(MCRegister RegA, MCRegister RegB) const {
return isSuperRegister(RegB, RegA);
}
/// Returns true if RegB is a super-register of RegA.
- bool isSuperRegister(unsigned RegA, unsigned RegB) const;
+ bool isSuperRegister(MCRegister RegA, MCRegister RegB) const;
/// Returns true if RegB is a sub-register of RegA or if RegB == RegA.
- bool isSubRegisterEq(unsigned RegA, unsigned RegB) const {
+ bool isSubRegisterEq(MCRegister RegA, MCRegister RegB) const {
return isSuperRegisterEq(RegB, RegA);
}
/// Returns true if RegB is a super-register of RegA or if
/// RegB == RegA.
- bool isSuperRegisterEq(unsigned RegA, unsigned RegB) const {
+ bool isSuperRegisterEq(MCRegister RegA, MCRegister RegB) const {
return RegA == RegB || isSuperRegister(RegA, RegB);
}
/// Returns true if RegB is a super-register or sub-register of RegA
/// or if RegB == RegA.
- bool isSuperOrSubRegisterEq(unsigned RegA, unsigned RegB) const {
+ bool isSuperOrSubRegisterEq(MCRegister RegA, MCRegister RegB) const {
return isSubRegisterEq(RegA, RegB) || isSuperRegister(RegA, RegB);
}
};
@@ -482,8 +586,8 @@
/// If IncludeSelf is set, Reg itself is included in the list.
class MCSubRegIterator : public MCRegisterInfo::DiffListIterator {
public:
- MCSubRegIterator(unsigned Reg, const MCRegisterInfo *MCRI,
- bool IncludeSelf = false) {
+ MCSubRegIterator(MCRegister Reg, const MCRegisterInfo *MCRI,
+ bool IncludeSelf = false) {
init(Reg, MCRI->DiffLists + MCRI->get(Reg).SubRegs);
// Initially, the iterator points to Reg itself.
if (!IncludeSelf)
@@ -500,13 +604,13 @@
public:
/// Constructs an iterator that traverses subregisters and their
/// associated subregister indices.
- MCSubRegIndexIterator(unsigned Reg, const MCRegisterInfo *MCRI)
+ MCSubRegIndexIterator(MCRegister Reg, const MCRegisterInfo *MCRI)
: SRIter(Reg, MCRI) {
SRIndex = MCRI->SubRegIndices + MCRI->get(Reg).SubRegIndices;
}
/// Returns current sub-register.
- unsigned getSubReg() const {
+ MCRegister getSubReg() const {
return *SRIter;
}
@@ -531,7 +635,7 @@
public:
MCSuperRegIterator() = default;
- MCSuperRegIterator(unsigned Reg, const MCRegisterInfo *MCRI,
+ MCSuperRegIterator(MCRegister Reg, const MCRegisterInfo *MCRI,
bool IncludeSelf = false) {
init(Reg, MCRI->DiffLists + MCRI->get(Reg).SuperRegs);
// Initially, the iterator points to Reg itself.
@@ -542,7 +646,7 @@
// Definition for isSuperRegister. Put it down here since it needs the
// iterator defined above in addition to the MCRegisterInfo class itself.
-inline bool MCRegisterInfo::isSuperRegister(unsigned RegA, unsigned RegB) const{
+inline bool MCRegisterInfo::isSuperRegister(MCRegister RegA, MCRegister RegB) const{
for (MCSuperRegIterator I(RegA, this); I.isValid(); ++I)
if (*I == RegB)
return true;
@@ -569,8 +673,9 @@
/// in Reg.
MCRegUnitIterator() = default;
- MCRegUnitIterator(unsigned Reg, const MCRegisterInfo *MCRI) {
+ MCRegUnitIterator(MCRegister Reg, const MCRegisterInfo *MCRI) {
assert(Reg && "Null register has no regunits");
+ assert(MCRegister::isPhysicalRegister(Reg.id()));
// Decode the RegUnits MCRegisterDesc field.
unsigned RU = MCRI->get(Reg).RegUnits;
unsigned Scale = RU & 15;
@@ -600,7 +705,7 @@
/// Constructs an iterator that traverses the register units and their
/// associated LaneMasks in Reg.
- MCRegUnitMaskIterator(unsigned Reg, const MCRegisterInfo *MCRI)
+ MCRegUnitMaskIterator(MCRegister Reg, const MCRegisterInfo *MCRI)
: RUIter(Reg, MCRI) {
uint16_t Idx = MCRI->get(Reg).RegUnitLaneMasks;
MaskListIter = &MCRI->RegUnitMaskSequences[Idx];
@@ -667,7 +772,7 @@
/// any ordering or that entries are unique.
class MCRegAliasIterator {
private:
- unsigned Reg;
+ MCRegister Reg;
const MCRegisterInfo *MCRI;
bool IncludeSelf;
@@ -676,7 +781,7 @@
MCSuperRegIterator SI;
public:
- MCRegAliasIterator(unsigned Reg, const MCRegisterInfo *MCRI,
+ MCRegAliasIterator(MCRegister Reg, const MCRegisterInfo *MCRI,
bool IncludeSelf)
: Reg(Reg), MCRI(MCRI), IncludeSelf(IncludeSelf) {
// Initialize the iterators.
@@ -692,7 +797,7 @@
bool isValid() const { return RI.isValid(); }
- unsigned operator*() const {
+ MCRegister operator*() const {
assert(SI.isValid() && "Cannot dereference an invalid iterator.");
return *SI;
}
diff --git a/linux-x64/clang/include/llvm/MC/MCSchedule.h b/linux-x64/clang/include/llvm/MC/MCSchedule.h
index df3248e..ee0e5b4 100644
--- a/linux-x64/clang/include/llvm/MC/MCSchedule.h
+++ b/linux-x64/clang/include/llvm/MC/MCSchedule.h
@@ -14,7 +14,6 @@
#ifndef LLVM_MC_MCSCHEDULE_H
#define LLVM_MC_MCSCHEDULE_H
-#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Optional.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/Support/DataTypes.h"
@@ -22,6 +21,7 @@
namespace llvm {
+template <typename T> class ArrayRef;
struct InstrItinerary;
class MCSubtargetInfo;
class MCInstrInfo;
@@ -205,7 +205,7 @@
/// subtargets can't be done. Nonetheless, the abstract model is
/// useful. Futhermore, subtargets typically extend this model with processor
/// specific resources to model any hardware features that can be exploited by
-/// sceduling heuristics and aren't sufficiently represented in the abstract.
+/// scheduling heuristics and aren't sufficiently represented in the abstract.
///
/// The abstract pipeline is built around the notion of an "issue point". This
/// is merely a reference point for counting machine cycles. The physical
diff --git a/linux-x64/clang/include/llvm/MC/MCSection.h b/linux-x64/clang/include/llvm/MC/MCSection.h
index 6fad1ec..a68e06e 100644
--- a/linux-x64/clang/include/llvm/MC/MCSection.h
+++ b/linux-x64/clang/include/llvm/MC/MCSection.h
@@ -17,6 +17,7 @@
#include "llvm/ADT/ilist.h"
#include "llvm/MC/MCFragment.h"
#include "llvm/MC/SectionKind.h"
+#include "llvm/Support/Alignment.h"
#include <cassert>
#include <utility>
@@ -37,6 +38,8 @@
/// current translation unit. The MCContext class uniques and creates these.
class MCSection {
public:
+ static constexpr unsigned NonUniqueID = ~0U;
+
enum SectionVariant { SV_COFF = 0, SV_ELF, SV_MachO, SV_Wasm, SV_XCOFF };
/// Express the state of bundle locked groups while emitting code.
@@ -58,7 +61,7 @@
MCSymbol *Begin;
MCSymbol *End = nullptr;
/// The alignment requirement of this section.
- unsigned Alignment = 1;
+ Align Alignment;
/// The section index in the assemblers section list.
unsigned Ordinal = 0;
/// The index of this section in the layout order.
@@ -77,10 +80,6 @@
/// Whether this section has had instructions emitted into it.
bool HasInstructions : 1;
- /// Whether this section has had data emitted into it.
- /// Right now this is only used by the ARM backend.
- bool HasData : 1;
-
bool IsRegistered : 1;
MCDummyFragment DummyFragment;
@@ -91,17 +90,29 @@
/// below that number.
SmallVector<std::pair<unsigned, MCFragment *>, 1> SubsectionFragmentMap;
+ /// State for tracking labels that don't yet have Fragments
+ struct PendingLabel {
+ MCSymbol* Sym;
+ unsigned Subsection;
+ PendingLabel(MCSymbol* Sym, unsigned Subsection = 0)
+ : Sym(Sym), Subsection(Subsection) {}
+ };
+ SmallVector<PendingLabel, 2> PendingLabels;
+
protected:
+ // TODO Make Name private when possible.
+ StringRef Name;
SectionVariant Variant;
SectionKind Kind;
- MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin);
+ MCSection(SectionVariant V, StringRef Name, SectionKind K, MCSymbol *Begin);
~MCSection();
public:
MCSection(const MCSection &) = delete;
MCSection &operator=(const MCSection &) = delete;
+ StringRef getName() const { return Name; }
SectionKind getKind() const { return Kind; }
SectionVariant getVariant() const { return Variant; }
@@ -117,8 +128,8 @@
MCSymbol *getEndSymbol(MCContext &Ctx);
bool hasEnded() const;
- unsigned getAlignment() const { return Alignment; }
- void setAlignment(unsigned Value) { Alignment = Value; }
+ unsigned getAlignment() const { return Alignment.value(); }
+ void setAlignment(Align Value) { Alignment = Value; }
unsigned getOrdinal() const { return Ordinal; }
void setOrdinal(unsigned Value) { Ordinal = Value; }
@@ -140,9 +151,6 @@
bool hasInstructions() const { return HasInstructions; }
void setHasInstructions(bool Value) { HasInstructions = Value; }
- bool hasData() const { return HasData; }
- void setHasData(bool Value) { HasData = Value; }
-
bool isRegistered() const { return IsRegistered; }
void setIsRegistered(bool Value) { IsRegistered = Value; }
@@ -165,12 +173,6 @@
iterator end() { return Fragments.end(); }
const_iterator end() const { return Fragments.end(); }
- reverse_iterator rbegin() { return Fragments.rbegin(); }
- const_reverse_iterator rbegin() const { return Fragments.rbegin(); }
-
- reverse_iterator rend() { return Fragments.rend(); }
- const_reverse_iterator rend() const { return Fragments.rend(); }
-
MCSection::iterator getSubsectionInsertionPoint(unsigned Subsection);
void dump() const;
@@ -186,6 +188,20 @@
/// Check whether this section is "virtual", that is has no actual object
/// file contents.
virtual bool isVirtualSection() const = 0;
+
+ virtual StringRef getVirtualSectionKind() const;
+
+ /// Add a pending label for the requested subsection. This label will be
+ /// associated with a fragment in flushPendingLabels()
+ void addPendingLabel(MCSymbol* label, unsigned Subsection = 0);
+
+ /// Associate all pending labels in a subsection with a fragment.
+ void flushPendingLabels(MCFragment *F, uint64_t FOffset = 0,
+ unsigned Subsection = 0);
+
+ /// Associate all pending labels with empty data fragments. One fragment
+ /// will be created for each subsection as necessary.
+ void flushPendingLabels();
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h b/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h
index 8be95e0..3ece6eb 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionCOFF.h
@@ -24,9 +24,6 @@
/// This represents a section on Windows
class MCSectionCOFF final : public MCSection {
- // The memory for this string is stored in the same MCContext as *this.
- StringRef SectionName;
-
// FIXME: The following fields should not be mutable, but are for now so the
// asm parser can honor the .linkonce directive.
@@ -51,12 +48,12 @@
private:
friend class MCContext;
- MCSectionCOFF(StringRef Section, unsigned Characteristics,
+ // The storage of Name is owned by MCContext's COFFUniquingMap.
+ MCSectionCOFF(StringRef Name, unsigned Characteristics,
MCSymbol *COMDATSymbol, int Selection, SectionKind K,
MCSymbol *Begin)
- : MCSection(SV_COFF, K, Begin), SectionName(Section),
- Characteristics(Characteristics), COMDATSymbol(COMDATSymbol),
- Selection(Selection) {
+ : MCSection(SV_COFF, Name, K, Begin), Characteristics(Characteristics),
+ COMDATSymbol(COMDATSymbol), Selection(Selection) {
assert((Characteristics & 0x00F00000) == 0 &&
"alignment must not be set upon section creation");
}
@@ -66,7 +63,6 @@
/// section name
bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
- StringRef getSectionName() const { return SectionName; }
unsigned getCharacteristics() const { return Characteristics; }
MCSymbol *getCOMDATSymbol() const { return COMDATSymbol; }
int getSelection() const { return Selection; }
@@ -78,6 +74,7 @@
const MCExpr *Subsection) const override;
bool UseCodeAlign() const override;
bool isVirtualSection() const override;
+ StringRef getVirtualSectionKind() const override;
unsigned getOrAssignWinCFISectionID(unsigned *NextID) const {
if (WinCFISectionID == ~0U)
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionELF.h b/linux-x64/clang/include/llvm/MC/MCSectionELF.h
index fe6b2d7..4136ea7 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionELF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionELF.h
@@ -25,10 +25,6 @@
/// This represents a section on linux, lots of unix variants and some bare
/// metal systems.
class MCSectionELF final : public MCSection {
- /// This is the name of the section. The referenced memory is owned by
- /// TargetLoweringObjectFileELF's ELFUniqueMap.
- StringRef SectionName;
-
/// This is the sh_type field of a section, drawn from the enums below.
unsigned Type;
@@ -44,30 +40,33 @@
const MCSymbolELF *Group;
- /// sh_info for SHF_LINK_ORDER (can be null).
- const MCSymbol *AssociatedSymbol;
+ /// Used by SHF_LINK_ORDER. If non-null, the sh_link field will be set to the
+ /// section header index of the section where LinkedToSym is defined.
+ const MCSymbol *LinkedToSym;
private:
friend class MCContext;
- MCSectionELF(StringRef Section, unsigned type, unsigned flags, SectionKind K,
+ // The storage of Name is owned by MCContext's ELFUniquingMap.
+ MCSectionELF(StringRef Name, unsigned type, unsigned flags, SectionKind K,
unsigned entrySize, const MCSymbolELF *group, unsigned UniqueID,
- MCSymbol *Begin, const MCSymbolELF *AssociatedSymbol)
- : MCSection(SV_ELF, K, Begin), SectionName(Section), Type(type),
- Flags(flags), UniqueID(UniqueID), EntrySize(entrySize), Group(group),
- AssociatedSymbol(AssociatedSymbol) {
+ MCSymbol *Begin, const MCSymbolELF *LinkedToSym)
+ : MCSection(SV_ELF, Name, K, Begin), Type(type), Flags(flags),
+ UniqueID(UniqueID), EntrySize(entrySize), Group(group),
+ LinkedToSym(LinkedToSym) {
if (Group)
Group->setIsSignature();
}
- void setSectionName(StringRef Name) { SectionName = Name; }
+ // TODO Delete after we stop supporting generation of GNU-style .zdebug_*
+ // sections.
+ void setSectionName(StringRef Name) { this->Name = Name; }
public:
/// Decides whether a '.section' directive should be printed before the
/// section name
bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
- StringRef getSectionName() const { return SectionName; }
unsigned getType() const { return Type; }
unsigned getFlags() const { return Flags; }
unsigned getEntrySize() const { return EntrySize; }
@@ -79,12 +78,15 @@
const MCExpr *Subsection) const override;
bool UseCodeAlign() const override;
bool isVirtualSection() const override;
+ StringRef getVirtualSectionKind() const override;
- bool isUnique() const { return UniqueID != ~0U; }
+ bool isUnique() const { return UniqueID != NonUniqueID; }
unsigned getUniqueID() const { return UniqueID; }
- const MCSection *getAssociatedSection() const { return &AssociatedSymbol->getSection(); }
- const MCSymbol *getAssociatedSymbol() const { return AssociatedSymbol; }
+ const MCSection *getLinkedToSection() const {
+ return &LinkedToSym->getSection();
+ }
+ const MCSymbol *getLinkedToSymbol() const { return LinkedToSym; }
static bool classof(const MCSection *S) {
return S->getVariant() == SV_ELF;
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionMachO.h b/linux-x64/clang/include/llvm/MC/MCSectionMachO.h
index 2c73661..b675585 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionMachO.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionMachO.h
@@ -23,7 +23,6 @@
/// system, these are also described in /usr/include/mach-o/loader.h.
class MCSectionMachO final : public MCSection {
char SegmentName[16]; // Not necessarily null terminated!
- char SectionName[16]; // Not necessarily null terminated!
/// This is the SECTION_TYPE and SECTION_ATTRIBUTES field of a section, drawn
/// from the enums below.
@@ -44,12 +43,6 @@
return StringRef(SegmentName, 16);
return StringRef(SegmentName);
}
- StringRef getSectionName() const {
- // SectionName is not necessarily null terminated!
- if (SectionName[15])
- return StringRef(SectionName, 16);
- return StringRef(SectionName);
- }
unsigned getTypeAndAttributes() const { return TypeAndAttributes; }
unsigned getStubSize() const { return Reserved2; }
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionWasm.h b/linux-x64/clang/include/llvm/MC/MCSectionWasm.h
index 1adc812..6211afe 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionWasm.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionWasm.h
@@ -13,22 +13,17 @@
#ifndef LLVM_MC_MCSECTIONWASM_H
#define LLVM_MC_MCSECTIONWASM_H
-#include "llvm/ADT/Twine.h"
#include "llvm/MC/MCSection.h"
-#include "llvm/MC/MCSymbolWasm.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
namespace llvm {
class MCSymbol;
+class MCSymbolWasm;
+class StringRef;
+class raw_ostream;
/// This represents a section on wasm.
class MCSectionWasm final : public MCSection {
- /// This is the name of the section. The referenced memory is owned by
- /// TargetLoweringObjectFileWasm's WasmUniqueMap.
- StringRef SectionName;
-
unsigned UniqueID;
const MCSymbolWasm *Group;
@@ -45,18 +40,17 @@
// Whether this data segment is passive
bool IsPassive = false;
+ // The storage of Name is owned by MCContext's WasmUniquingMap.
friend class MCContext;
- MCSectionWasm(StringRef Section, SectionKind K, const MCSymbolWasm *group,
+ MCSectionWasm(StringRef Name, SectionKind K, const MCSymbolWasm *group,
unsigned UniqueID, MCSymbol *Begin)
- : MCSection(SV_Wasm, K, Begin), SectionName(Section), UniqueID(UniqueID),
- Group(group) {}
+ : MCSection(SV_Wasm, Name, K, Begin), UniqueID(UniqueID), Group(group) {}
public:
/// Decides whether a '.section' directive should be printed before the
/// section name
bool shouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
- StringRef getSectionName() const { return SectionName; }
const MCSymbolWasm *getGroup() const { return Group; }
void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
@@ -66,7 +60,8 @@
bool isVirtualSection() const override;
bool isWasmData() const {
- return Kind.isGlobalWriteableData() || Kind.isReadOnly();
+ return Kind.isGlobalWriteableData() || Kind.isReadOnly() ||
+ Kind.isThreadLocal();
}
bool isUnique() const { return UniqueID != ~0U; }
diff --git a/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h b/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h
index 2a3f391..aa39dff 100644
--- a/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSectionXCOFF.h
@@ -13,26 +13,50 @@
#ifndef LLVM_MC_MCSECTIONXCOFF_H
#define LLVM_MC_MCSECTIONXCOFF_H
-#include "llvm/ADT/Twine.h"
#include "llvm/BinaryFormat/XCOFF.h"
#include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
namespace llvm {
-class MCSymbol;
-
// This class represents an XCOFF `Control Section`, more commonly referred to
// as a csect. A csect represents the smallest possible unit of data/code which
-// will be relocated as a single block.
+// will be relocated as a single block. A csect can either be:
+// 1) Initialized: The Type will be XTY_SD, and the symbols inside the csect
+// will have a label definition representing their offset within the csect.
+// 2) Uninitialized: The Type will be XTY_CM, it will contain a single symbol,
+// and may not contain label definitions.
+// 3) An external reference providing a symbol table entry for a symbol
+// contained in another XCOFF object file. External reference csects are not
+// implemented yet.
class MCSectionXCOFF final : public MCSection {
friend class MCContext;
- StringRef Name;
XCOFF::StorageMappingClass MappingClass;
+ XCOFF::SymbolType Type;
+ MCSymbolXCOFF *const QualName;
+ StringRef SymbolTableName;
+ bool MultiSymbolsAllowed;
+ static constexpr unsigned DefaultAlignVal = 4;
- MCSectionXCOFF(StringRef Section, XCOFF::StorageMappingClass SMC,
- SectionKind K, MCSymbol *Begin)
- : MCSection(SV_XCOFF, K, Begin), Name(Section), MappingClass(SMC) {}
+ MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
+ XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName,
+ MCSymbol *Begin, StringRef SymbolTableName,
+ bool MultiSymbolsAllowed)
+ : MCSection(SV_XCOFF, Name, K, Begin), MappingClass(SMC), Type(ST),
+ QualName(QualName), SymbolTableName(SymbolTableName),
+ MultiSymbolsAllowed(MultiSymbolsAllowed) {
+ assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
+ "Invalid or unhandled type for csect.");
+ assert(QualName != nullptr && "QualName is needed.");
+ QualName->setRepresentedCsect(this);
+ QualName->setStorageClass(XCOFF::C_HIDEXT);
+ // A csect is 4 byte aligned by default, except for undefined symbol csects.
+ if (Type != XCOFF::XTY_ER)
+ setAlignment(Align(DefaultAlignVal));
+ }
+
+ void printCsectDirective(raw_ostream &OS) const;
public:
~MCSectionXCOFF();
@@ -41,14 +65,20 @@
return S->getVariant() == SV_XCOFF;
}
- StringRef getSectionName() const { return Name; }
XCOFF::StorageMappingClass getMappingClass() const { return MappingClass; }
+ XCOFF::StorageClass getStorageClass() const {
+ return QualName->getStorageClass();
+ }
+ XCOFF::SymbolType getCSectType() const { return Type; }
+ MCSymbolXCOFF *getQualNameSymbol() const { return QualName; }
void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
raw_ostream &OS,
const MCExpr *Subsection) const override;
bool UseCodeAlign() const override;
bool isVirtualSection() const override;
+ StringRef getSymbolTableName() const { return SymbolTableName; }
+ bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCStreamer.h b/linux-x64/clang/include/llvm/MC/MCStreamer.h
index 67284fb..cdc728f 100644
--- a/linux-x64/clang/include/llvm/MC/MCStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCStreamer.h
@@ -13,6 +13,7 @@
#ifndef LLVM_MC_MCSTREAMER_H
#define LLVM_MC_MCSTREAMER_H
+#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Optional.h"
@@ -20,6 +21,7 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCLinkerOptimizationHint.h"
+#include "llvm/MC/MCPseudoProbe.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCWinEH.h"
#include "llvm/Support/Error.h"
@@ -40,12 +42,12 @@
class formatted_raw_ostream;
class MCAsmBackend;
class MCCodeEmitter;
-struct MCCodePaddingContext;
class MCContext;
struct MCDwarfFrameInfo;
class MCExpr;
class MCInst;
class MCInstPrinter;
+class MCRegister;
class MCSection;
class MCStreamer;
class MCSymbolRefExpr;
@@ -53,6 +55,13 @@
class raw_ostream;
class Twine;
+namespace codeview {
+struct DefRangeRegisterRelHeader;
+struct DefRangeSubfieldRegisterHeader;
+struct DefRangeRegisterHeader;
+struct DefRangeFramePointerRelHeader;
+}
+
using MCSectionSubPair = std::pair<MCSection *, const MCExpr *>;
/// Target specific streamer interface. This is used so that targets can
@@ -95,8 +104,9 @@
// Allow a target to add behavior to the emitAssignment of MCStreamer.
virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value);
- virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, raw_ostream &OS,
- const MCInst &Inst, const MCSubtargetInfo &STI);
+ virtual void prettyPrintAsm(MCInstPrinter &InstPrinter, uint64_t Address,
+ const MCInst &Inst, const MCSubtargetInfo &STI,
+ raw_ostream &OS);
virtual void emitDwarfFileDirective(StringRef Directive);
@@ -146,7 +156,7 @@
StringRef StringValue = "");
virtual void emitFPU(unsigned FPU);
virtual void emitArch(ARM::ArchKind Arch);
- virtual void emitArchExtension(unsigned ArchExt);
+ virtual void emitArchExtension(uint64_t ArchExt);
virtual void emitObjectArch(ARM::ArchKind Arch);
void emitTargetAttributes(const MCSubtargetInfo &STI);
virtual void finishAttributeSection();
@@ -197,6 +207,7 @@
std::vector<std::unique_ptr<WinEH::FrameInfo>> WinFrameInfos;
WinEH::FrameInfo *CurrentWinFrameInfo;
+ size_t CurrentProcWinFrameInfoStartIndex;
/// Tracks an index to represent the order a symbol was emitted in.
/// Zero means we did not emit that symbol.
@@ -206,6 +217,10 @@
/// PushSection.
SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
+ /// Pointer to the parser's SMLoc if available. This is used to provide
+ /// locations for diagnostics.
+ const SMLoc *StartTokLocPtr = nullptr;
+
/// The next unique ID to use when creating a WinCFI-related section (.pdata
/// or .xdata). This ID ensures that we have a one-to-one mapping from
/// code section to unwind info section, which MSVC's incremental linker
@@ -214,19 +229,28 @@
bool UseAssemblerInfoForParsing;
+ /// Is the assembler allowed to insert padding automatically? For
+ /// correctness reasons, we sometimes need to ensure instructions aren't
+ /// seperated in unexpected ways. At the moment, this feature is only
+ /// useable from an integrated assembler, but assembly syntax is under
+ /// discussion for future inclusion.
+ bool AllowAutoPadding = false;
+
protected:
MCStreamer(MCContext &Ctx);
- virtual void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
- virtual void EmitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
+ virtual void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
+ virtual void emitCFIEndProcImpl(MCDwarfFrameInfo &CurFrame);
WinEH::FrameInfo *getCurrentWinFrameInfo() {
return CurrentWinFrameInfo;
}
+ virtual void EmitWindowsUnwindTables(WinEH::FrameInfo *Frame);
+
virtual void EmitWindowsUnwindTables();
- virtual void EmitRawTextImpl(StringRef String);
+ virtual void emitRawTextImpl(StringRef String);
/// Returns true if the the .cv_loc directive is in the right section.
bool checkCVLocSection(unsigned FuncId, unsigned FileNo, SMLoc Loc);
@@ -243,6 +267,11 @@
TargetStreamer.reset(TS);
}
+ void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; }
+ SMLoc getStartTokLoc() const {
+ return StartTokLocPtr ? *StartTokLocPtr : SMLoc();
+ }
+
/// State management
///
virtual void reset();
@@ -258,9 +287,12 @@
return TargetStreamer.get();
}
+ void setAllowAutoPadding(bool v) { AllowAutoPadding = v; }
+ bool getAllowAutoPadding() const { return AllowAutoPadding; }
+
/// When emitting an object file, create and emit a real label. When emitting
/// textual assembly, this should do nothing to avoid polluting our output.
- virtual MCSymbol *EmitCFILabel();
+ virtual MCSymbol *emitCFILabel();
/// Retreive the current frame info if one is available and it is not yet
/// closed. Otherwise, issue an error and return null.
@@ -359,7 +391,7 @@
///
/// This is called by PopSection and SwitchSection, if the current
/// section changes.
- virtual void ChangeSection(MCSection *, const MCExpr *);
+ virtual void changeSection(MCSection *, const MCExpr *);
/// Save the current and previous section on the section stack.
void PushSection() {
@@ -368,7 +400,7 @@
}
/// Restore the current and previous section from the section stack.
- /// Calls ChangeSection as needed.
+ /// Calls changeSection as needed.
///
/// Returns false if the stack was empty.
bool PopSection() {
@@ -380,8 +412,8 @@
--I;
MCSectionSubPair NewSection = I->first;
- if (OldSection != NewSection)
- ChangeSection(NewSection.first, NewSection.second);
+ if (NewSection.first && OldSection != NewSection)
+ changeSection(NewSection.first, NewSection.second);
SectionStack.pop_back();
return true;
}
@@ -403,7 +435,7 @@
/// Set the current section where code is being emitted to \p Section.
/// This is required to update CurSection. This version does not call
- /// ChangeSection.
+ /// changeSection.
void SwitchSectionNoChange(MCSection *Section,
const MCExpr *Subsection = nullptr) {
assert(Section && "Cannot switch to a null section!");
@@ -424,6 +456,10 @@
/// so we can sort on them later.
void AssignFragment(MCSymbol *Symbol, MCFragment *Fragment);
+ /// Returns the mnemonic for \p MI, if the streamer has access to a
+ /// instruction printer and returns an empty string otherwise.
+ virtual StringRef getMnemonic(MCInst &MI) { return ""; }
+
/// Emit a label for \p Symbol into the current section.
///
/// This corresponds to an assembler statement such as:
@@ -434,37 +470,37 @@
/// used in an assignment.
// FIXME: These emission are non-const because we mutate the symbol to
// add the section we're emitting it to later.
- virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc());
+ virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc());
- virtual void EmitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol);
+ virtual void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol);
/// Note in the output the specified \p Flag.
- virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
+ virtual void emitAssemblerFlag(MCAssemblerFlag Flag);
/// Emit the given list \p Options of strings as linker
/// options into the output.
- virtual void EmitLinkerOptions(ArrayRef<std::string> Kind) {}
+ virtual void emitLinkerOptions(ArrayRef<std::string> Kind) {}
/// Note in the output the specified region \p Kind.
- virtual void EmitDataRegion(MCDataRegionType Kind) {}
+ virtual void emitDataRegion(MCDataRegionType Kind) {}
/// Specify the Mach-O minimum deployment target version.
- virtual void EmitVersionMin(MCVersionMinType Type, unsigned Major,
+ virtual void emitVersionMin(MCVersionMinType Type, unsigned Major,
unsigned Minor, unsigned Update,
VersionTuple SDKVersion) {}
/// Emit/Specify Mach-O build version command.
/// \p Platform should be one of MachO::PlatformType.
- virtual void EmitBuildVersion(unsigned Platform, unsigned Major,
+ virtual void emitBuildVersion(unsigned Platform, unsigned Major,
unsigned Minor, unsigned Update,
VersionTuple SDKVersion) {}
- void EmitVersionForTarget(const Triple &Target,
+ void emitVersionForTarget(const Triple &Target,
const VersionTuple &SDKVersion);
/// Note in the output that the specified \p Func is a Thumb mode
/// function (ARM target only).
- virtual void EmitThumbFunc(MCSymbol *Func);
+ virtual void emitThumbFunc(MCSymbol *Func);
/// Emit an assignment of \p Value to \p Symbol.
///
@@ -477,7 +513,7 @@
///
/// \param Symbol - The symbol being assigned to.
/// \param Value - The value for the symbol.
- virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
+ virtual void emitAssignment(MCSymbol *Symbol, const MCExpr *Value);
/// Emit an weak reference from \p Alias to \p Symbol.
///
@@ -486,17 +522,17 @@
///
/// \param Alias - The alias that is being created.
/// \param Symbol - The symbol being aliased.
- virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
+ virtual void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
/// Add the given \p Attribute to \p Symbol.
- virtual bool EmitSymbolAttribute(MCSymbol *Symbol,
+ virtual bool emitSymbolAttribute(MCSymbol *Symbol,
MCSymbolAttr Attribute) = 0;
/// Set the \p DescValue for the \p Symbol.
///
/// \param Symbol - The symbol to have its n_desc field set.
/// \param DescValue - The value to set into the n_desc field.
- virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
+ virtual void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
/// Start emitting COFF symbol definition
///
@@ -536,6 +572,36 @@
/// \param Symbol - Symbol the image relative relocation should point to.
virtual void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset);
+ /// Emits an lcomm directive with XCOFF csect information.
+ ///
+ /// \param LabelSym - Label on the block of storage.
+ /// \param Size - The size of the block of storage.
+ /// \param CsectSym - Csect name for the block of storage.
+ /// \param ByteAlignment - The alignment of the symbol in bytes. Must be a
+ /// power of 2.
+ virtual void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
+ MCSymbol *CsectSym,
+ unsigned ByteAlignment);
+
+ /// Emit a symbol's linkage and visibilty with a linkage directive for XCOFF.
+ ///
+ /// \param Symbol - The symbol to emit.
+ /// \param Linkage - The linkage of the symbol to emit.
+ /// \param Visibility - The visibility of the symbol to emit or MCSA_Invalid
+ /// if the symbol does not have an explicit visibility.
+ virtual void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
+ MCSymbolAttr Linkage,
+ MCSymbolAttr Visibility);
+
+ /// Emit a XCOFF .rename directive which creates a synonym for an illegal or
+ /// undesirable name.
+ ///
+ /// \param Name - The name used internally in the assembly for references to
+ /// the symbol.
+ /// \param Rename - The value to which the Name parameter is
+ /// changed at the end of assembly.
+ virtual void emitXCOFFRenameDirective(const MCSymbol *Name, StringRef Rename);
+
/// Emit an ELF .size directive.
///
/// This corresponds to an assembler statement such as:
@@ -553,7 +619,7 @@
/// Emit a Linker Optimization Hint (LOH) directive.
/// \param Args - Arguments of the LOH.
- virtual void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
+ virtual void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {}
/// Emit a common symbol.
///
@@ -561,7 +627,7 @@
/// \param Size - The size of the common symbol.
/// \param ByteAlignment - The alignment of the symbol if
/// non-zero. This must be a power of 2.
- virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ virtual void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) = 0;
/// Emit a local common (.lcomm) symbol.
@@ -569,7 +635,7 @@
/// \param Symbol - The common symbol to emit.
/// \param Size - The size of the common symbol.
/// \param ByteAlignment - The alignment of the common symbol in bytes.
- virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ virtual void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment);
/// Emit the zerofill section and an optional symbol.
@@ -579,7 +645,7 @@
/// \param Size - The size of the zerofill symbol.
/// \param ByteAlignment - The alignment of the zerofill symbol if
/// non-zero. This must be a power of 2 on some targets.
- virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+ virtual void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
uint64_t Size = 0, unsigned ByteAlignment = 0,
SMLoc Loc = SMLoc()) = 0;
@@ -590,7 +656,7 @@
/// \param Size - The size of the symbol.
/// \param ByteAlignment - The alignment of the thread local common symbol
/// if non-zero. This must be a power of 2 on some targets.
- virtual void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
+ virtual void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
uint64_t Size, unsigned ByteAlignment = 0);
/// @}
@@ -601,11 +667,11 @@
///
/// This is used to implement assembler directives such as .byte, .ascii,
/// etc.
- virtual void EmitBytes(StringRef Data);
+ virtual void emitBytes(StringRef Data);
/// Functionally identical to EmitBytes. When emitting textual assembly, this
/// method uses .byte directives instead of .ascii or .asciz for readability.
- virtual void EmitBinaryData(StringRef Data);
+ virtual void emitBinaryData(StringRef Data);
/// Emit the expression \p Value into the output as a native
/// integer of the given \p Size bytes.
@@ -617,30 +683,50 @@
/// \param Size - The size of the integer (in bytes) to emit. This must
/// match a native machine width.
/// \param Loc - The location of the expression for error reporting.
- virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
+ virtual void emitValueImpl(const MCExpr *Value, unsigned Size,
SMLoc Loc = SMLoc());
- void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
+ void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
/// Special case of EmitValue that avoids the client having
/// to pass in a MCExpr for constant integers.
- virtual void EmitIntValue(uint64_t Value, unsigned Size);
+ virtual void emitIntValue(uint64_t Value, unsigned Size);
+ virtual void emitIntValue(APInt Value);
- virtual void EmitULEB128Value(const MCExpr *Value);
+ /// Special case of EmitValue that avoids the client having to pass
+ /// in a MCExpr for constant integers & prints in Hex format for certain
+ /// modes.
+ virtual void emitIntValueInHex(uint64_t Value, unsigned Size) {
+ emitIntValue(Value, Size);
+ }
- virtual void EmitSLEB128Value(const MCExpr *Value);
+ void emitInt8(uint64_t Value) { emitIntValue(Value, 1); }
+ void emitInt16(uint64_t Value) { emitIntValue(Value, 2); }
+ void emitInt32(uint64_t Value) { emitIntValue(Value, 4); }
+ void emitInt64(uint64_t Value) { emitIntValue(Value, 8); }
+
+ /// Special case of EmitValue that avoids the client having to pass
+ /// in a MCExpr for constant integers & prints in Hex format for certain
+ /// modes, pads the field with leading zeros to Size width
+ virtual void emitIntValueInHexWithPadding(uint64_t Value, unsigned Size) {
+ emitIntValue(Value, Size);
+ }
+
+ virtual void emitULEB128Value(const MCExpr *Value);
+
+ virtual void emitSLEB128Value(const MCExpr *Value);
/// Special case of EmitULEB128Value that avoids the client having to
/// pass in a MCExpr for constant integers.
- void EmitULEB128IntValue(uint64_t Value, unsigned PadTo = 0);
+ void emitULEB128IntValue(uint64_t Value, unsigned PadTo = 0);
/// Special case of EmitSLEB128Value that avoids the client having to
/// pass in a MCExpr for constant integers.
- void EmitSLEB128IntValue(int64_t Value);
+ void emitSLEB128IntValue(int64_t Value);
/// Special case of EmitValue that avoids the client having to pass in
/// a MCExpr for MCSymbols.
- void EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
+ void emitSymbolValue(const MCSymbol *Sym, unsigned Size,
bool IsSectionRelative = false);
/// Emit the expression \p Value into the output as a dtprel
@@ -648,42 +734,42 @@
///
/// This is used to implement assembler directives such as .dtpreldword on
/// targets that support them.
- virtual void EmitDTPRel64Value(const MCExpr *Value);
+ virtual void emitDTPRel64Value(const MCExpr *Value);
/// Emit the expression \p Value into the output as a dtprel
/// (32-bit DTP relative) value.
///
/// This is used to implement assembler directives such as .dtprelword on
/// targets that support them.
- virtual void EmitDTPRel32Value(const MCExpr *Value);
+ virtual void emitDTPRel32Value(const MCExpr *Value);
/// Emit the expression \p Value into the output as a tprel
/// (64-bit TP relative) value.
///
/// This is used to implement assembler directives such as .tpreldword on
/// targets that support them.
- virtual void EmitTPRel64Value(const MCExpr *Value);
+ virtual void emitTPRel64Value(const MCExpr *Value);
/// Emit the expression \p Value into the output as a tprel
/// (32-bit TP relative) value.
///
/// This is used to implement assembler directives such as .tprelword on
/// targets that support them.
- virtual void EmitTPRel32Value(const MCExpr *Value);
+ virtual void emitTPRel32Value(const MCExpr *Value);
/// Emit the expression \p Value into the output as a gprel64 (64-bit
/// GP relative) value.
///
/// This is used to implement assembler directives such as .gpdword on
/// targets that support them.
- virtual void EmitGPRel64Value(const MCExpr *Value);
+ virtual void emitGPRel64Value(const MCExpr *Value);
/// Emit the expression \p Value into the output as a gprel32 (32-bit
/// GP relative) value.
///
/// This is used to implement assembler directives such as .gprel32 on
/// targets that support them.
- virtual void EmitGPRel32Value(const MCExpr *Value);
+ virtual void emitGPRel32Value(const MCExpr *Value);
/// Emit NumBytes bytes worth of the value specified by FillValue.
/// This implements directives such as '.space'.
@@ -710,9 +796,12 @@
virtual void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
SMLoc Loc = SMLoc());
+ virtual void emitNops(int64_t NumBytes, int64_t ControlledNopLength,
+ SMLoc Loc);
+
/// Emit NumBytes worth of zeros.
/// This function properly handles data in virtual sections.
- void EmitZeros(uint64_t NumBytes);
+ void emitZeros(uint64_t NumBytes);
/// Emit some number of copies of \p Value until the byte alignment \p
/// ByteAlignment is reached.
@@ -731,7 +820,7 @@
/// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
/// the alignment cannot be reached in this many bytes, no bytes are
/// emitted.
- virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
+ virtual void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
unsigned ValueSize = 1,
unsigned MaxBytesToEmit = 0);
@@ -745,7 +834,7 @@
/// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If
/// the alignment cannot be reached in this many bytes, no bytes are
/// emitted.
- virtual void EmitCodeAlignment(unsigned ByteAlignment,
+ virtual void emitCodeAlignment(unsigned ByteAlignment,
unsigned MaxBytesToEmit = 0);
/// Emit some number of copies of \p Value until the byte offset \p
@@ -759,25 +848,19 @@
virtual void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
SMLoc Loc);
- virtual void
- EmitCodePaddingBasicBlockStart(const MCCodePaddingContext &Context) {}
-
- virtual void
- EmitCodePaddingBasicBlockEnd(const MCCodePaddingContext &Context) {}
-
/// @}
/// Switch to a new logical file. This is used to implement the '.file
/// "foo.c"' assembler directive.
- virtual void EmitFileDirective(StringRef Filename);
+ virtual void emitFileDirective(StringRef Filename);
/// Emit the "identifiers" directive. This implements the
/// '.ident "version foo"' assembler directive.
- virtual void EmitIdent(StringRef IdentString) {}
+ virtual void emitIdent(StringRef IdentString) {}
/// Associate a filename with a specified logical file number. This
/// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
- unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
+ unsigned emitDwarfFileDirective(unsigned FileNo, StringRef Directory,
StringRef Filename,
Optional<MD5::MD5Result> Checksum = None,
Optional<StringRef> Source = None,
@@ -803,11 +886,11 @@
Optional<StringRef> Source,
unsigned CUID = 0);
- virtual void EmitCFIBKeyFrame();
+ virtual void emitCFIBKeyFrame();
/// This implements the DWARF2 '.loc fileno lineno ...' assembler
/// directive.
- virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
+ virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line,
unsigned Column, unsigned Flags,
unsigned Isa, unsigned Discriminator,
StringRef FileName);
@@ -829,19 +912,19 @@
unsigned IACol, SMLoc Loc);
/// This implements the CodeView '.cv_loc' assembler directive.
- virtual void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
+ virtual void emitCVLocDirective(unsigned FunctionId, unsigned FileNo,
unsigned Line, unsigned Column,
bool PrologueEnd, bool IsStmt,
StringRef FileName, SMLoc Loc);
/// This implements the CodeView '.cv_linetable' assembler directive.
- virtual void EmitCVLinetableDirective(unsigned FunctionId,
+ virtual void emitCVLinetableDirective(unsigned FunctionId,
const MCSymbol *FnStart,
const MCSymbol *FnEnd);
/// This implements the CodeView '.cv_inline_linetable' assembler
/// directive.
- virtual void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
+ virtual void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
unsigned SourceFileId,
unsigned SourceLineNum,
const MCSymbol *FnStartSym,
@@ -849,19 +932,35 @@
/// This implements the CodeView '.cv_def_range' assembler
/// directive.
- virtual void EmitCVDefRangeDirective(
+ virtual void emitCVDefRangeDirective(
ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
StringRef FixedSizePortion);
+ virtual void emitCVDefRangeDirective(
+ ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+ codeview::DefRangeRegisterRelHeader DRHdr);
+
+ virtual void emitCVDefRangeDirective(
+ ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+ codeview::DefRangeSubfieldRegisterHeader DRHdr);
+
+ virtual void emitCVDefRangeDirective(
+ ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+ codeview::DefRangeRegisterHeader DRHdr);
+
+ virtual void emitCVDefRangeDirective(
+ ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+ codeview::DefRangeFramePointerRelHeader DRHdr);
+
/// This implements the CodeView '.cv_stringtable' assembler directive.
- virtual void EmitCVStringTableDirective() {}
+ virtual void emitCVStringTableDirective() {}
/// This implements the CodeView '.cv_filechecksums' assembler directive.
- virtual void EmitCVFileChecksumsDirective() {}
+ virtual void emitCVFileChecksumsDirective() {}
/// This implements the CodeView '.cv_filechecksumoffset' assembler
/// directive.
- virtual void EmitCVFileChecksumOffsetDirective(unsigned FileNo) {}
+ virtual void emitCVFileChecksumOffsetDirective(unsigned FileNo) {}
/// This implements the CodeView '.cv_fpo_data' assembler directive.
virtual void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc Loc = {}) {}
@@ -877,29 +976,29 @@
const MCSymbol *Lo);
virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID);
- virtual void EmitCFISections(bool EH, bool Debug);
- void EmitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
- void EmitCFIEndProc();
- virtual void EmitCFIDefCfa(int64_t Register, int64_t Offset);
- virtual void EmitCFIDefCfaOffset(int64_t Offset);
- virtual void EmitCFIDefCfaRegister(int64_t Register);
- virtual void EmitCFIOffset(int64_t Register, int64_t Offset);
- virtual void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
- virtual void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding);
- virtual void EmitCFIRememberState();
- virtual void EmitCFIRestoreState();
- virtual void EmitCFISameValue(int64_t Register);
- virtual void EmitCFIRestore(int64_t Register);
- virtual void EmitCFIRelOffset(int64_t Register, int64_t Offset);
- virtual void EmitCFIAdjustCfaOffset(int64_t Adjustment);
- virtual void EmitCFIEscape(StringRef Values);
- virtual void EmitCFIReturnColumn(int64_t Register);
- virtual void EmitCFIGnuArgsSize(int64_t Size);
- virtual void EmitCFISignalFrame();
- virtual void EmitCFIUndefined(int64_t Register);
- virtual void EmitCFIRegister(int64_t Register1, int64_t Register2);
- virtual void EmitCFIWindowSave();
- virtual void EmitCFINegateRAState();
+ virtual void emitCFISections(bool EH, bool Debug);
+ void emitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
+ void emitCFIEndProc();
+ virtual void emitCFIDefCfa(int64_t Register, int64_t Offset);
+ virtual void emitCFIDefCfaOffset(int64_t Offset);
+ virtual void emitCFIDefCfaRegister(int64_t Register);
+ virtual void emitCFIOffset(int64_t Register, int64_t Offset);
+ virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
+ virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding);
+ virtual void emitCFIRememberState();
+ virtual void emitCFIRestoreState();
+ virtual void emitCFISameValue(int64_t Register);
+ virtual void emitCFIRestore(int64_t Register);
+ virtual void emitCFIRelOffset(int64_t Register, int64_t Offset);
+ virtual void emitCFIAdjustCfaOffset(int64_t Adjustment);
+ virtual void emitCFIEscape(StringRef Values);
+ virtual void emitCFIReturnColumn(int64_t Register);
+ virtual void emitCFIGnuArgsSize(int64_t Size);
+ virtual void emitCFISignalFrame();
+ virtual void emitCFIUndefined(int64_t Register);
+ virtual void emitCFIRegister(int64_t Register1, int64_t Register2);
+ virtual void emitCFIWindowSave();
+ virtual void emitCFINegateRAState();
virtual void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc());
virtual void EmitWinCFIEndProc(SMLoc Loc = SMLoc());
@@ -910,13 +1009,13 @@
virtual void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc = SMLoc());
virtual void EmitWinCFIStartChained(SMLoc Loc = SMLoc());
virtual void EmitWinCFIEndChained(SMLoc Loc = SMLoc());
- virtual void EmitWinCFIPushReg(unsigned Register, SMLoc Loc = SMLoc());
- virtual void EmitWinCFISetFrame(unsigned Register, unsigned Offset,
+ virtual void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc = SMLoc());
+ virtual void EmitWinCFISetFrame(MCRegister Register, unsigned Offset,
SMLoc Loc = SMLoc());
virtual void EmitWinCFIAllocStack(unsigned Size, SMLoc Loc = SMLoc());
- virtual void EmitWinCFISaveReg(unsigned Register, unsigned Offset,
+ virtual void EmitWinCFISaveReg(MCRegister Register, unsigned Offset,
SMLoc Loc = SMLoc());
- virtual void EmitWinCFISaveXMM(unsigned Register, unsigned Offset,
+ virtual void EmitWinCFISaveXMM(MCRegister Register, unsigned Offset,
SMLoc Loc = SMLoc());
virtual void EmitWinCFIPushFrame(bool Code, SMLoc Loc = SMLoc());
virtual void EmitWinCFIEndProlog(SMLoc Loc = SMLoc());
@@ -935,46 +1034,50 @@
/// Get the .xdata section used for the given section.
MCSection *getAssociatedXDataSection(const MCSection *TextSec);
- virtual void EmitSyntaxDirective();
+ virtual void emitSyntaxDirective();
- /// Emit a .reloc directive.
- /// Returns true if the relocation could not be emitted because Name is not
- /// known.
- virtual bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
- const MCExpr *Expr, SMLoc Loc,
- const MCSubtargetInfo &STI) {
- return true;
+ /// Record a relocation described by the .reloc directive. Return None if
+ /// succeeded. Otherwise, return a pair (Name is invalid, error message).
+ virtual Optional<std::pair<bool, std::string>>
+ emitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr,
+ SMLoc Loc, const MCSubtargetInfo &STI) {
+ return None;
}
- virtual void EmitAddrsig() {}
- virtual void EmitAddrsigSym(const MCSymbol *Sym) {}
+ virtual void emitAddrsig() {}
+ virtual void emitAddrsigSym(const MCSymbol *Sym) {}
/// Emit the given \p Instruction into the current section.
- virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
+ virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
+
+ /// Emit the a pseudo probe into the current section.
+ virtual void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type,
+ uint64_t Attr,
+ const MCPseudoProbeInlineStack &InlineStack);
/// Set the bundle alignment mode from now on in the section.
/// The argument is the power of 2 to which the alignment is set. The
/// value 0 means turn the bundle alignment off.
- virtual void EmitBundleAlignMode(unsigned AlignPow2);
+ virtual void emitBundleAlignMode(unsigned AlignPow2);
/// The following instructions are a bundle-locked group.
///
/// \param AlignToEnd - If true, the bundle-locked group will be aligned to
/// the end of a bundle.
- virtual void EmitBundleLock(bool AlignToEnd);
+ virtual void emitBundleLock(bool AlignToEnd);
/// Ends a bundle-locked group.
- virtual void EmitBundleUnlock();
+ virtual void emitBundleUnlock();
/// If this file is backed by a assembly streamer, this dumps the
/// specified string in the output .s file. This capability is indicated by
/// the hasRawTextSupport() predicate. By default this aborts.
- void EmitRawText(const Twine &String);
+ void emitRawText(const Twine &String);
/// Streamer specific finalization.
- virtual void FinishImpl();
+ virtual void finishImpl();
/// Finish emission of machine code.
- void Finish();
+ void Finish(SMLoc EndLoc = SMLoc());
virtual bool mayHaveInstructions(MCSection &Sec) const { return true; }
};
@@ -983,28 +1086,6 @@
/// timing the assembler front end.
MCStreamer *createNullStreamer(MCContext &Ctx);
-/// Create a machine code streamer which will print out assembly for the native
-/// target, suitable for compiling with a native assembler.
-///
-/// \param InstPrint - If given, the instruction printer to use. If not given
-/// the MCInst representation will be printed. This method takes ownership of
-/// InstPrint.
-///
-/// \param CE - If given, a code emitter to use to show the instruction
-/// encoding inline with the assembly. This method takes ownership of \p CE.
-///
-/// \param TAB - If given, a target asm backend to use to show the fixup
-/// information in conjunction with encoding information. This method takes
-/// ownership of \p TAB.
-///
-/// \param ShowInst - Whether to show the MCInst representation inline with
-/// the assembly.
-MCStreamer *createAsmStreamer(MCContext &Ctx,
- std::unique_ptr<formatted_raw_ostream> OS,
- bool isVerboseAsm, bool useDwarfDirectory,
- MCInstPrinter *InstPrint, MCCodeEmitter *CE,
- MCAsmBackend *TAB, bool ShowInst);
-
} // end namespace llvm
#endif // LLVM_MC_MCSTREAMER_H
diff --git a/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h b/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h
index 9490a6e..2c1072d 100644
--- a/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h
+++ b/linux-x64/clang/include/llvm/MC/MCSubtargetInfo.h
@@ -54,6 +54,7 @@
struct SubtargetSubTypeKV {
const char *Key; ///< K-V key string
FeatureBitArray Implies; ///< K-V bit mask
+ FeatureBitArray TuneImplies; ///< K-V bit mask
const MCSchedModel *SchedModel;
/// Compare routine for std::lower_bound
@@ -74,6 +75,7 @@
class MCSubtargetInfo {
Triple TargetTriple;
std::string CPU; // CPU being targeted.
+ std::string TuneCPU; // CPU being tuned for.
ArrayRef<SubtargetFeatureKV> ProcFeatures; // Processor feature list
ArrayRef<SubtargetSubTypeKV> ProcDesc; // Processor descriptions
@@ -90,8 +92,8 @@
public:
MCSubtargetInfo(const MCSubtargetInfo &) = default;
- MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS,
- ArrayRef<SubtargetFeatureKV> PF,
+ MCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef TuneCPU,
+ StringRef FS, ArrayRef<SubtargetFeatureKV> PF,
ArrayRef<SubtargetSubTypeKV> PD,
const MCWriteProcResEntry *WPR, const MCWriteLatencyEntry *WL,
const MCReadAdvanceEntry *RA, const InstrStage *IS,
@@ -103,6 +105,7 @@
const Triple &getTargetTriple() const { return TargetTriple; }
StringRef getCPU() const { return CPU; }
+ StringRef getTuneCPU() const { return TuneCPU; }
const FeatureBitset& getFeatureBits() const { return FeatureBits; }
void setFeatureBits(const FeatureBitset &FeatureBits_) {
@@ -118,12 +121,12 @@
///
/// FIXME: Find a way to stick this in the constructor, since it should only
/// be called during initialization.
- void InitMCProcessorInfo(StringRef CPU, StringRef FS);
+ void InitMCProcessorInfo(StringRef CPU, StringRef TuneCPU, StringRef FS);
public:
- /// Set the features to the default for the given CPU with an appended feature
- /// string.
- void setDefaultFeatures(StringRef CPU, StringRef FS);
+ /// Set the features to the default for the given CPU and TuneCPU, with ano
+ /// appended feature string.
+ void setDefaultFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);
/// Toggle a feature and return the re-computed feature bits.
/// This version does not change the implied bits.
@@ -210,17 +213,71 @@
void initInstrItins(InstrItineraryData &InstrItins) const;
/// Resolve a variant scheduling class for the given MCInst and CPU.
- virtual unsigned
- resolveVariantSchedClass(unsigned SchedClass, const MCInst *MI,
- unsigned CPUID) const {
+ virtual unsigned resolveVariantSchedClass(unsigned SchedClass,
+ const MCInst *MI,
+ const MCInstrInfo *MCII,
+ unsigned CPUID) const {
return 0;
}
/// Check whether the CPU string is valid.
bool isCPUStringValid(StringRef CPU) const {
- auto Found = std::lower_bound(ProcDesc.begin(), ProcDesc.end(), CPU);
+ auto Found = llvm::lower_bound(ProcDesc, CPU);
return Found != ProcDesc.end() && StringRef(Found->Key) == CPU;
}
+
+ virtual unsigned getHwMode() const { return 0; }
+
+ /// Return the cache size in bytes for the given level of cache.
+ /// Level is zero-based, so a value of zero means the first level of
+ /// cache.
+ ///
+ virtual Optional<unsigned> getCacheSize(unsigned Level) const;
+
+ /// Return the cache associatvity for the given level of cache.
+ /// Level is zero-based, so a value of zero means the first level of
+ /// cache.
+ ///
+ virtual Optional<unsigned> getCacheAssociativity(unsigned Level) const;
+
+ /// Return the target cache line size in bytes at a given level.
+ ///
+ virtual Optional<unsigned> getCacheLineSize(unsigned Level) const;
+
+ /// Return the target cache line size in bytes. By default, return
+ /// the line size for the bottom-most level of cache. This provides
+ /// a more convenient interface for the common case where all cache
+ /// levels have the same line size. Return zero if there is no
+ /// cache model.
+ ///
+ virtual unsigned getCacheLineSize() const {
+ Optional<unsigned> Size = getCacheLineSize(0);
+ if (Size)
+ return *Size;
+
+ return 0;
+ }
+
+ /// Return the preferred prefetch distance in terms of instructions.
+ ///
+ virtual unsigned getPrefetchDistance() const;
+
+ /// Return the maximum prefetch distance in terms of loop
+ /// iterations.
+ ///
+ virtual unsigned getMaxPrefetchIterationsAhead() const;
+
+ /// \return True if prefetching should also be done for writes.
+ ///
+ virtual bool enableWritePrefetching() const;
+
+ /// Return the minimum stride necessary to trigger software
+ /// prefetching.
+ ///
+ virtual unsigned getMinPrefetchStride(unsigned NumMemAccesses,
+ unsigned NumStridedMemAccesses,
+ unsigned NumPrefetches,
+ bool HasCall) const;
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCSymbol.h b/linux-x64/clang/include/llvm/MC/MCSymbol.h
index 189484d..a83781f 100644
--- a/linux-x64/clang/include/llvm/MC/MCSymbol.h
+++ b/linux-x64/clang/include/llvm/MC/MCSymbol.h
@@ -16,6 +16,7 @@
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCFragment.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
@@ -27,7 +28,6 @@
class MCAsmInfo;
class MCContext;
-class MCExpr;
class MCSection;
class raw_ostream;
@@ -94,7 +94,8 @@
mutable unsigned IsRegistered : 1;
- /// This symbol is visible outside this translation unit.
+ /// True if this symbol is visible outside this translation unit. Note: ELF
+ /// uses binding instead of this bit.
mutable unsigned IsExternal : 1;
/// This symbol is private extern.
@@ -178,14 +179,6 @@
llvm_unreachable("Constructor throws?");
}
- MCSection *getSectionPtr() const {
- if (MCFragment *F = getFragment()) {
- assert(F != AbsolutePseudoFragment);
- return F->getParent();
- }
- return nullptr;
- }
-
/// Get a reference to the name field. Requires that we have a name
const StringMapEntry<bool> *&getNameEntryPtr() {
assert(FragmentAndHasName.getInt() && "Name is required");
@@ -267,7 +260,7 @@
/// Get the section associated with a defined, non-absolute symbol.
MCSection &getSection() const {
assert(isInSection() && "Invalid accessor!");
- return *getSectionPtr();
+ return *getFragment()->getParent();
}
/// Mark the symbol as defined in the fragment \p F.
diff --git a/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h b/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h
index c50cd0e..ae512fd 100644
--- a/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h
+++ b/linux-x64/clang/include/llvm/MC/MCSymbolWasm.h
@@ -18,11 +18,14 @@
bool IsWeak = false;
bool IsHidden = false;
bool IsComdat = false;
+ mutable bool IsUsedInInitArray = false;
mutable bool IsUsedInGOT = false;
- Optional<std::string> ImportModule;
- Optional<std::string> ImportName;
+ Optional<StringRef> ImportModule;
+ Optional<StringRef> ImportName;
+ Optional<StringRef> ExportName;
wasm::WasmSignature *Signature = nullptr;
Optional<wasm::WasmGlobalType> GlobalType;
+ Optional<wasm::ValType> TableType;
Optional<wasm::WasmEventType> EventType;
/// An expression describing how to calculate the size of a symbol. If a
@@ -30,8 +33,6 @@
const MCExpr *SymbolSize = nullptr;
public:
- // Use a module name of "env" for now, for compatibility with existing tools.
- // This is temporary, and may change, as the ABI is not yet stable.
MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
: MCSymbol(SymbolKindWasm, Name, isTemporary) {}
static bool classof(const MCSymbol *S) { return S->isWasm(); }
@@ -42,6 +43,7 @@
bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
bool isData() const { return Type == wasm::WASM_SYMBOL_TYPE_DATA; }
bool isGlobal() const { return Type == wasm::WASM_SYMBOL_TYPE_GLOBAL; }
+ bool isTable() const { return Type == wasm::WASM_SYMBOL_TYPE_TABLE; }
bool isSection() const { return Type == wasm::WASM_SYMBOL_TYPE_SECTION; }
bool isEvent() const { return Type == wasm::WASM_SYMBOL_TYPE_EVENT; }
wasm::WasmSymbolType getType() const { return Type; }
@@ -54,6 +56,13 @@
modifyFlags(wasm::WASM_SYMBOL_EXPORTED, wasm::WASM_SYMBOL_EXPORTED);
}
+ bool isNoStrip() const {
+ return getFlags() & wasm::WASM_SYMBOL_NO_STRIP;
+ }
+ void setNoStrip() const {
+ modifyFlags(wasm::WASM_SYMBOL_NO_STRIP, wasm::WASM_SYMBOL_NO_STRIP);
+ }
+
bool isWeak() const { return IsWeak; }
void setWeak(bool isWeak) { IsWeak = isWeak; }
@@ -63,25 +72,45 @@
bool isComdat() const { return IsComdat; }
void setComdat(bool isComdat) { IsComdat = isComdat; }
- const StringRef getImportModule() const {
- if (ImportModule.hasValue()) {
- return ImportModule.getValue();
- }
- return "env";
+ bool hasImportModule() const { return ImportModule.hasValue(); }
+ StringRef getImportModule() const {
+ if (ImportModule.hasValue())
+ return ImportModule.getValue();
+ // Use a default module name of "env" for now, for compatibility with
+ // existing tools.
+ // TODO(sbc): Find a way to specify a default value in the object format
+ // without picking a hardcoded value like this.
+ return "env";
}
void setImportModule(StringRef Name) { ImportModule = Name; }
- const StringRef getImportName() const {
- if (ImportName.hasValue()) {
- return ImportName.getValue();
- }
- return getName();
+ bool hasImportName() const { return ImportName.hasValue(); }
+ StringRef getImportName() const {
+ if (ImportName.hasValue())
+ return ImportName.getValue();
+ return getName();
}
void setImportName(StringRef Name) { ImportName = Name; }
+ bool hasExportName() const { return ExportName.hasValue(); }
+ StringRef getExportName() const { return ExportName.getValue(); }
+ void setExportName(StringRef Name) { ExportName = Name; }
+
+ bool isFunctionTable() const {
+ return isTable() && hasTableType() &&
+ getTableType() == wasm::ValType::FUNCREF;
+ }
+ void setFunctionTable() {
+ setType(wasm::WASM_SYMBOL_TYPE_TABLE);
+ setTableType(wasm::ValType::FUNCREF);
+ }
+
void setUsedInGOT() const { IsUsedInGOT = true; }
bool isUsedInGOT() const { return IsUsedInGOT; }
+ void setUsedInInitArray() const { IsUsedInInitArray = true; }
+ bool isUsedInInitArray() const { return IsUsedInInitArray; }
+
const wasm::WasmSignature *getSignature() const { return Signature; }
void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
@@ -91,6 +120,13 @@
}
void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; }
+ bool hasTableType() const { return TableType.hasValue(); }
+ wasm::ValType getTableType() const {
+ assert(hasTableType());
+ return TableType.getValue();
+ }
+ void setTableType(wasm::ValType TT) { TableType = TT; }
+
const wasm::WasmEventType &getEventType() const {
assert(EventType.hasValue());
return EventType.getValue();
diff --git a/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h b/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h
index 30cbf0b..752e1e7 100644
--- a/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h
+++ b/linux-x64/clang/include/llvm/MC/MCSymbolXCOFF.h
@@ -8,27 +8,67 @@
#ifndef LLVM_MC_MCSYMBOLXCOFF_H
#define LLVM_MC_MCSYMBOLXCOFF_H
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/XCOFF.h"
#include "llvm/MC/MCSymbol.h"
namespace llvm {
-class GlobalValue;
+class MCSectionXCOFF;
class MCSymbolXCOFF : public MCSymbol {
- // The IR symbol this MCSymbolXCOFF is based on. It is set on function
- // entry point symbols when they are the callee operand of a direct call
- // SDNode.
- const GlobalValue *GV = nullptr;
-
public:
MCSymbolXCOFF(const StringMapEntry<bool> *Name, bool isTemporary)
: MCSymbol(SymbolKindXCOFF, Name, isTemporary) {}
- void setGlobalValue(const GlobalValue *G) { GV = G; }
- const GlobalValue *getGlobalValue() const { return GV; }
-
static bool classof(const MCSymbol *S) { return S->isXCOFF(); }
+
+ static StringRef getUnqualifiedName(StringRef Name) {
+ if (Name.back() == ']') {
+ StringRef Lhs, Rhs;
+ std::tie(Lhs, Rhs) = Name.rsplit('[');
+ assert(!Rhs.empty() && "Invalid SMC format in XCOFF symbol.");
+ return Lhs;
+ }
+ return Name;
+ }
+
+ void setStorageClass(XCOFF::StorageClass SC) {
+ StorageClass = SC;
+ };
+
+ XCOFF::StorageClass getStorageClass() const {
+ assert(StorageClass.hasValue() &&
+ "StorageClass not set on XCOFF MCSymbol.");
+ return StorageClass.getValue();
+ }
+
+ StringRef getUnqualifiedName() const { return getUnqualifiedName(getName()); }
+
+ MCSectionXCOFF *getRepresentedCsect() const;
+
+ void setRepresentedCsect(MCSectionXCOFF *C);
+
+ void setVisibilityType(XCOFF::VisibilityType SVT) { VisibilityType = SVT; };
+
+ XCOFF::VisibilityType getVisibilityType() const { return VisibilityType; }
+
+ bool hasRename() const { return !SymbolTableName.empty(); }
+
+ void setSymbolTableName(StringRef STN) { SymbolTableName = STN; }
+
+ StringRef getSymbolTableName() const {
+ if (hasRename())
+ return SymbolTableName;
+ return getUnqualifiedName();
+ }
+
+private:
+ Optional<XCOFF::StorageClass> StorageClass;
+ MCSectionXCOFF *RepresentedCsect = nullptr;
+ XCOFF::VisibilityType VisibilityType = XCOFF::SYM_V_UNSPECIFIED;
+ StringRef SymbolTableName;
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCTargetOptions.h b/linux-x64/clang/include/llvm/MC/MCTargetOptions.h
index f184620..d29a749 100644
--- a/linux-x64/clang/include/llvm/MC/MCTargetOptions.h
+++ b/linux-x64/clang/include/llvm/MC/MCTargetOptions.h
@@ -9,6 +9,7 @@
#ifndef LLVM_MC_MCTARGETOPTIONS_H
#define LLVM_MC_MCTARGETOPTIONS_H
+#include "llvm/ADT/ArrayRef.h"
#include <string>
#include <vector>
@@ -21,6 +22,7 @@
ARM, ///< ARM EHABI
WinEH, ///< Windows Exception Handling
Wasm, ///< WebAssembly Exception Handling
+ AIX, ///< AIX Exception Handling
};
enum class DebugCompressionType {
@@ -46,7 +48,6 @@
bool MCSaveTempLabels : 1;
bool MCUseDwarfDirectory : 1;
bool MCIncrementalLinkerCompatible : 1;
- bool MCPIECopyRelocations : 1;
bool ShowMCEncoding : 1;
bool ShowMCInst : 1;
bool AsmVerbose : 1;
@@ -54,11 +55,16 @@
/// Preserve Comments in Assembly.
bool PreserveAsmComments : 1;
+ bool Dwarf64 : 1;
int DwarfVersion = 0;
std::string ABIName;
+ std::string AssemblyLanguage;
std::string SplitDwarfFile;
+ const char *Argv0 = nullptr;
+ ArrayRef<const char *> CommandLineArgs;
+
/// Additional paths to search for `.include` directives when using the
/// integrated assembler.
std::vector<std::string> IASSearchPaths;
@@ -69,6 +75,11 @@
/// textual name of the ABI that we want the backend to use, e.g. o32, or
/// aapcs-linux.
StringRef getABIName() const;
+
+ /// getAssemblyLanguage - If this returns a non-empty string this represents
+ /// the textual name of the assembly language that we will use for this
+ /// target, e.g. masm.
+ StringRef getAssemblyLanguage() const;
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.h b/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.h
new file mode 100644
index 0000000..6d3c477
--- /dev/null
+++ b/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.h
@@ -0,0 +1,57 @@
+//===-- MCTargetOptionsCommandFlags.h --------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains machine code-specific flags that are shared between
+// different command line tools.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
+#define LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
+
+#include "llvm/ADT/Optional.h"
+#include <string>
+
+namespace llvm {
+
+class MCTargetOptions;
+
+namespace mc {
+
+bool getRelaxAll();
+Optional<bool> getExplicitRelaxAll();
+
+bool getIncrementalLinkerCompatible();
+
+int getDwarfVersion();
+
+bool getDwarf64();
+
+bool getShowMCInst();
+
+bool getFatalWarnings();
+
+bool getNoWarn();
+
+bool getNoDeprecatedWarn();
+
+std::string getABIName();
+
+/// Create this object with static storage to register mc-related command
+/// line options.
+struct RegisterMCTargetOptionsFlags {
+ RegisterMCTargetOptionsFlags();
+};
+
+MCTargetOptions InitMCTargetOptionsFromFlags();
+
+} // namespace mc
+
+} // namespace llvm
+
+#endif
diff --git a/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.inc b/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.inc
deleted file mode 100644
index 9f1177f..0000000
--- a/linux-x64/clang/include/llvm/MC/MCTargetOptionsCommandFlags.inc
+++ /dev/null
@@ -1,68 +0,0 @@
-//===-- MCTargetOptionsCommandFlags.h --------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains machine code-specific flags that are shared between
-// different command line tools.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
-#define LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
-
-#include "llvm/MC/MCTargetOptions.h"
-#include "llvm/Support/CommandLine.h"
-using namespace llvm;
-
-static cl::opt<bool> RelaxAll("mc-relax-all",
- cl::desc("When used with filetype=obj, "
- "relax all fixups in the emitted object file"));
-
-static cl::opt<bool> IncrementalLinkerCompatible(
- "incremental-linker-compatible",
- cl::desc(
- "When used with filetype=obj, "
- "emit an object file which can be used with an incremental linker"));
-
-static cl::opt<bool> PIECopyRelocations("pie-copy-relocations", cl::desc("PIE Copy Relocations"));
-
-static cl::opt<int> DwarfVersion("dwarf-version", cl::desc("Dwarf version"),
- cl::init(0));
-
-static cl::opt<bool> ShowMCInst("asm-show-inst",
- cl::desc("Emit internal instruction representation to "
- "assembly file"));
-
-static cl::opt<bool> FatalWarnings("fatal-warnings",
- cl::desc("Treat warnings as errors"));
-
-static cl::opt<bool> NoWarn("no-warn", cl::desc("Suppress all warnings"));
-static cl::alias NoWarnW("W", cl::desc("Alias for --no-warn"), cl::aliasopt(NoWarn));
-
-static cl::opt<bool> NoDeprecatedWarn("no-deprecated-warn",
- cl::desc("Suppress all deprecated warnings"));
-
-static cl::opt<std::string>
-ABIName("target-abi", cl::Hidden,
- cl::desc("The name of the ABI to be targeted from the backend."),
- cl::init(""));
-
-static MCTargetOptions InitMCTargetOptionsFromFlags() {
- MCTargetOptions Options;
- Options.MCRelaxAll = RelaxAll;
- Options.MCIncrementalLinkerCompatible = IncrementalLinkerCompatible;
- Options.MCPIECopyRelocations = PIECopyRelocations;
- Options.DwarfVersion = DwarfVersion;
- Options.ShowMCInst = ShowMCInst;
- Options.ABIName = ABIName;
- Options.MCFatalWarnings = FatalWarnings;
- Options.MCNoWarn = NoWarn;
- Options.MCNoDeprecatedWarn = NoDeprecatedWarn;
- return Options;
-}
-
-#endif
diff --git a/linux-x64/clang/include/llvm/MC/MCValue.h b/linux-x64/clang/include/llvm/MC/MCValue.h
index 0be7ce7..37feee4 100644
--- a/linux-x64/clang/include/llvm/MC/MCValue.h
+++ b/linux-x64/clang/include/llvm/MC/MCValue.h
@@ -14,12 +14,10 @@
#define LLVM_MC_MCVALUE_H
#include "llvm/MC/MCExpr.h"
-#include "llvm/MC/MCSymbol.h"
#include "llvm/Support/DataTypes.h"
#include <cassert>
namespace llvm {
-class MCAsmInfo;
class raw_ostream;
/// This represents an "assembler immediate".
diff --git a/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h
index 4adbca2..00da632 100644
--- a/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCWasmObjectWriter.h
@@ -20,14 +20,15 @@
class MCWasmObjectTargetWriter : public MCObjectTargetWriter {
const unsigned Is64Bit : 1;
+ const unsigned IsEmscripten : 1;
protected:
- explicit MCWasmObjectTargetWriter(bool Is64Bit_);
+ explicit MCWasmObjectTargetWriter(bool Is64Bit_, bool IsEmscripten);
public:
virtual ~MCWasmObjectTargetWriter();
- virtual Triple::ObjectFormatType getFormat() const { return Triple::Wasm; }
+ Triple::ObjectFormatType getFormat() const override { return Triple::Wasm; }
static bool classof(const MCObjectTargetWriter *W) {
return W->getFormat() == Triple::Wasm;
}
@@ -38,6 +39,7 @@
/// \name Accessors
/// @{
bool is64Bit() const { return Is64Bit; }
+ bool isEmscripten() const { return IsEmscripten; }
/// @}
};
@@ -50,6 +52,10 @@
createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
raw_pwrite_stream &OS);
+std::unique_ptr<MCObjectWriter>
+createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
+ raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS);
+
} // namespace llvm
#endif
diff --git a/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h b/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h
index 2d7f2b9..6651f07 100644
--- a/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCWasmStreamer.h
@@ -11,18 +11,14 @@
#include "MCAsmBackend.h"
#include "MCCodeEmitter.h"
-#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCObjectStreamer.h"
#include "llvm/MC/MCObjectWriter.h"
-#include "llvm/MC/SectionKind.h"
#include "llvm/Support/DataTypes.h"
namespace llvm {
-class MCAssembler;
class MCExpr;
class MCInst;
-class raw_ostream;
class MCWasmStreamer : public MCObjectStreamer {
public:
@@ -44,37 +40,33 @@
/// \name MCStreamer Interface
/// @{
- void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
- void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
- void EmitThumbFunc(MCSymbol *Func) override;
- void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
- bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
- void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
- void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ void changeSection(MCSection *Section, const MCExpr *Subsection) override;
+ void emitAssemblerFlag(MCAssemblerFlag Flag) override;
+ void emitThumbFunc(MCSymbol *Func) override;
+ void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+ bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+ void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
+ void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
- void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
- void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+ void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
uint64_t Size = 0, unsigned ByteAlignment = 0,
SMLoc Loc = SMLoc()) override;
- void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+ void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment = 0) override;
- void EmitValueImpl(const MCExpr *Value, unsigned Size,
- SMLoc Loc = SMLoc()) override;
- void EmitIdent(StringRef IdentString) override;
+ void emitIdent(StringRef IdentString) override;
- void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
-
- void FinishImpl() override;
+ void finishImpl() override;
private:
- void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
- void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+ void emitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
+ void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
/// Merge the content of the fragment \p EF into the fragment \p DF.
void mergeFragment(MCDataFragment *, MCDataFragment *);
diff --git a/linux-x64/clang/include/llvm/MC/MCWin64EH.h b/linux-x64/clang/include/llvm/MC/MCWin64EH.h
index 60ec06e..065161d 100644
--- a/linux-x64/clang/include/llvm/MC/MCWin64EH.h
+++ b/linux-x64/clang/include/llvm/MC/MCWin64EH.h
@@ -53,14 +53,15 @@
class UnwindEmitter : public WinEH::UnwindEmitter {
public:
void Emit(MCStreamer &Streamer) const override;
- void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI) const override;
+ void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI,
+ bool HandlerData) const override;
};
class ARM64UnwindEmitter : public WinEH::UnwindEmitter {
public:
void Emit(MCStreamer &Streamer) const override;
- void EmitUnwindInfo(MCStreamer &Streamer,
- WinEH::FrameInfo *FI) const override;
+ void EmitUnwindInfo(MCStreamer &Streamer, WinEH::FrameInfo *FI,
+ bool HandlerData) const override;
};
}
diff --git a/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h
index 3fe124f..3015efe 100644
--- a/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCWinCOFFObjectWriter.h
@@ -31,7 +31,7 @@
public:
virtual ~MCWinCOFFObjectTargetWriter() = default;
- virtual Triple::ObjectFormatType getFormat() const { return Triple::COFF; }
+ Triple::ObjectFormatType getFormat() const override { return Triple::COFF; }
static bool classof(const MCObjectTargetWriter *W) {
return W->getFormat() == Triple::COFF;
}
diff --git a/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h b/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h
index c1c1ec5..53b2ef0 100644
--- a/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCWinCOFFStreamer.h
@@ -40,11 +40,11 @@
/// \{
void InitSections(bool NoExecStack) override;
- void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
- void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
- void EmitThumbFunc(MCSymbol *Func) override;
- bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
- void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
+ void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
+ void emitAssemblerFlag(MCAssemblerFlag Flag) override;
+ void emitThumbFunc(MCSymbol *Func) override;
+ bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+ void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
void BeginCOFFSymbolDef(MCSymbol const *Symbol) override;
void EmitCOFFSymbolStorageClass(int StorageClass) override;
void EmitCOFFSymbolType(int Type) override;
@@ -54,24 +54,30 @@
void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
void EmitCOFFSecRel32(MCSymbol const *Symbol, uint64_t Offset) override;
void EmitCOFFImgRel32(MCSymbol const *Symbol, int64_t Offset) override;
- void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
- void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
- void EmitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+ void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
+ void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
- void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
+ void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
- void EmitIdent(StringRef IdentString) override;
+ void emitIdent(StringRef IdentString) override;
void EmitWinEHHandlerData(SMLoc Loc) override;
- void FinishImpl() override;
+ void emitCGProfileEntry(const MCSymbolRefExpr *From,
+ const MCSymbolRefExpr *To, uint64_t Count) override;
+ void finishImpl() override;
/// \}
protected:
const MCSymbol *CurSymbol;
- void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+ void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+
+ void finalizeCGProfileEntry(const MCSymbolRefExpr *&S);
+ void finalizeCGProfile();
private:
void Error(const Twine &Msg) const;
diff --git a/linux-x64/clang/include/llvm/MC/MCWinEH.h b/linux-x64/clang/include/llvm/MC/MCWinEH.h
index b1c28c0..5688255 100644
--- a/linux-x64/clang/include/llvm/MC/MCWinEH.h
+++ b/linux-x64/clang/include/llvm/MC/MCWinEH.h
@@ -26,6 +26,14 @@
Instruction(unsigned Op, MCSymbol *L, unsigned Reg, unsigned Off)
: Label(L), Offset(Off), Register(Reg), Operation(Op) {}
+
+ bool operator==(const Instruction &I) const {
+ // Check whether two instructions refer to the same operation
+ // applied at a different spot (i.e. pointing at a different label).
+ return Offset == I.Offset && Register == I.Register &&
+ Operation == I.Operation;
+ }
+ bool operator!=(const Instruction &I) const { return !(*this == I); }
};
struct FrameInfo {
@@ -36,10 +44,12 @@
const MCSymbol *Function = nullptr;
const MCSymbol *PrologEnd = nullptr;
const MCSymbol *Symbol = nullptr;
- const MCSection *TextSection = nullptr;
+ MCSection *TextSection = nullptr;
+ uint32_t PackedInfo = 0;
bool HandlesUnwind = false;
bool HandlesExceptions = false;
+ bool EmitAttempted = false;
int LastFrameInst = -1;
const FrameInfo *ChainedParent = nullptr;
@@ -53,6 +63,15 @@
const FrameInfo *ChainedParent)
: Begin(BeginFuncEHLabel), Function(Function),
ChainedParent(ChainedParent) {}
+
+ bool empty() const {
+ if (!Instructions.empty())
+ return false;
+ for (const auto &E : EpilogMap)
+ if (!E.second.empty())
+ return false;
+ return true;
+ }
};
class UnwindEmitter {
@@ -61,7 +80,8 @@
/// This emits the unwind info sections (.pdata and .xdata in PE/COFF).
virtual void Emit(MCStreamer &Streamer) const = 0;
- virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI) const = 0;
+ virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI,
+ bool HandlerData) const = 0;
};
}
}
diff --git a/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h b/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h
index fe4087f..faad2ce 100644
--- a/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h
+++ b/linux-x64/clang/include/llvm/MC/MCXCOFFObjectWriter.h
@@ -28,6 +28,13 @@
}
bool is64Bit() const { return Is64Bit; }
+ // Returns relocation info such as type, sign and size.
+ // First element of the pair contains type,
+ // second element contains sign and size.
+ virtual std::pair<uint8_t, uint8_t>
+ getRelocTypeAndSignSize(const MCValue &Target, const MCFixup &Fixup,
+ bool IsPCRel) const = 0;
+
private:
bool Is64Bit;
};
diff --git a/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h b/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h
index 159ae48..5fc2efb 100644
--- a/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h
+++ b/linux-x64/clang/include/llvm/MC/MCXCOFFStreamer.h
@@ -19,13 +19,24 @@
std::unique_ptr<MCObjectWriter> OW,
std::unique_ptr<MCCodeEmitter> Emitter);
- bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
- void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+ bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
+ void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
unsigned ByteAlignment) override;
- void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+ void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
uint64_t Size = 0, unsigned ByteAlignment = 0,
SMLoc Loc = SMLoc()) override;
- void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+ void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
+ void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
+ MCSymbol *CsectSym,
+ unsigned ByteAlign) override;
+ void emitXCOFFSymbolLinkageWithVisibility(MCSymbol *Symbol,
+ MCSymbolAttr Linkage,
+ MCSymbolAttr Visibility) override;
+ void emitXCOFFRenameDirective(const MCSymbol *Name,
+ StringRef Rename) override {
+ report_fatal_error("emitXCOFFRenameDirective is not implemented yet on "
+ "object generation path");
+ }
};
} // end namespace llvm
diff --git a/linux-x64/clang/include/llvm/MC/StringTableBuilder.h b/linux-x64/clang/include/llvm/MC/StringTableBuilder.h
index c83eca4..3f9c91b 100644
--- a/linux-x64/clang/include/llvm/MC/StringTableBuilder.h
+++ b/linux-x64/clang/include/llvm/MC/StringTableBuilder.h
@@ -22,7 +22,17 @@
/// Utility for building string tables with deduplicated suffixes.
class StringTableBuilder {
public:
- enum Kind { ELF, WinCOFF, MachO, RAW, DWARF };
+ enum Kind {
+ ELF,
+ WinCOFF,
+ MachO,
+ MachO64,
+ MachOLinked,
+ MachO64Linked,
+ RAW,
+ DWARF,
+ XCOFF
+ };
private:
DenseMap<CachedHashStringRef, size_t> StringIndexMap;
@@ -59,6 +69,16 @@
return getOffset(CachedHashStringRef(S));
}
+ /// Check if a string is contained in the string table. Since this class
+ /// doesn't store the string values, this function can be used to check if
+ /// storage needs to be done prior to adding the string.
+ bool contains(StringRef S) const {
+ return contains(CachedHashStringRef(S));
+ }
+ bool contains(CachedHashStringRef S) const {
+ return StringIndexMap.count(S);
+ }
+
size_t getSize() const { return Size; }
void clear();
diff --git a/linux-x64/clang/include/llvm/MC/SubtargetFeature.h b/linux-x64/clang/include/llvm/MC/SubtargetFeature.h
index fc9565c..cc36b25 100644
--- a/linux-x64/clang/include/llvm/MC/SubtargetFeature.h
+++ b/linux-x64/clang/include/llvm/MC/SubtargetFeature.h
@@ -18,6 +18,7 @@
#define LLVM_MC_SUBTARGETFEATURE_H
#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MathExtras.h"
#include <array>
#include <bitset>
#include <initializer_list>
@@ -29,24 +30,127 @@
class raw_ostream;
class Triple;
-const unsigned MAX_SUBTARGET_WORDS = 3;
+const unsigned MAX_SUBTARGET_WORDS = 4;
const unsigned MAX_SUBTARGET_FEATURES = MAX_SUBTARGET_WORDS * 64;
/// Container class for subtarget features.
-/// This is convenient because std::bitset does not have a constructor
-/// with an initializer list of set bits.
-class FeatureBitset : public std::bitset<MAX_SUBTARGET_FEATURES> {
+/// This is a constexpr reimplementation of a subset of std::bitset. It would be
+/// nice to use std::bitset directly, but it doesn't support constant
+/// initialization.
+class FeatureBitset {
+ static_assert((MAX_SUBTARGET_FEATURES % 64) == 0,
+ "Should be a multiple of 64!");
+ // This cannot be a std::array, operator[] is not constexpr until C++17.
+ uint64_t Bits[MAX_SUBTARGET_WORDS] = {};
+
+protected:
+ constexpr FeatureBitset(const std::array<uint64_t, MAX_SUBTARGET_WORDS> &B) {
+ for (unsigned I = 0; I != B.size(); ++I)
+ Bits[I] = B[I];
+ }
+
public:
- // Cannot inherit constructors because it's not supported by VC++..
- FeatureBitset() = default;
-
- FeatureBitset(const bitset<MAX_SUBTARGET_FEATURES>& B) : bitset(B) {}
-
- FeatureBitset(std::initializer_list<unsigned> Init) {
+ constexpr FeatureBitset() = default;
+ constexpr FeatureBitset(std::initializer_list<unsigned> Init) {
for (auto I : Init)
set(I);
}
+ FeatureBitset &set() {
+ std::fill(std::begin(Bits), std::end(Bits), -1ULL);
+ return *this;
+ }
+
+ constexpr FeatureBitset &set(unsigned I) {
+ // GCC <6.2 crashes if this is written in a single statement.
+ uint64_t NewBits = Bits[I / 64] | (uint64_t(1) << (I % 64));
+ Bits[I / 64] = NewBits;
+ return *this;
+ }
+
+ constexpr FeatureBitset &reset(unsigned I) {
+ // GCC <6.2 crashes if this is written in a single statement.
+ uint64_t NewBits = Bits[I / 64] & ~(uint64_t(1) << (I % 64));
+ Bits[I / 64] = NewBits;
+ return *this;
+ }
+
+ constexpr FeatureBitset &flip(unsigned I) {
+ // GCC <6.2 crashes if this is written in a single statement.
+ uint64_t NewBits = Bits[I / 64] ^ (uint64_t(1) << (I % 64));
+ Bits[I / 64] = NewBits;
+ return *this;
+ }
+
+ constexpr bool operator[](unsigned I) const {
+ uint64_t Mask = uint64_t(1) << (I % 64);
+ return (Bits[I / 64] & Mask) != 0;
+ }
+
+ constexpr bool test(unsigned I) const { return (*this)[I]; }
+
+ constexpr size_t size() const { return MAX_SUBTARGET_FEATURES; }
+
+ bool any() const {
+ return llvm::any_of(Bits, [](uint64_t I) { return I != 0; });
+ }
+ bool none() const { return !any(); }
+ size_t count() const {
+ size_t Count = 0;
+ for (auto B : Bits)
+ Count += countPopulation(B);
+ return Count;
+ }
+
+ constexpr FeatureBitset &operator^=(const FeatureBitset &RHS) {
+ for (unsigned I = 0, E = array_lengthof(Bits); I != E; ++I) {
+ Bits[I] ^= RHS.Bits[I];
+ }
+ return *this;
+ }
+ constexpr FeatureBitset operator^(const FeatureBitset &RHS) const {
+ FeatureBitset Result = *this;
+ Result ^= RHS;
+ return Result;
+ }
+
+ constexpr FeatureBitset &operator&=(const FeatureBitset &RHS) {
+ for (unsigned I = 0, E = array_lengthof(Bits); I != E; ++I) {
+ Bits[I] &= RHS.Bits[I];
+ }
+ return *this;
+ }
+ constexpr FeatureBitset operator&(const FeatureBitset &RHS) const {
+ FeatureBitset Result = *this;
+ Result &= RHS;
+ return Result;
+ }
+
+ constexpr FeatureBitset &operator|=(const FeatureBitset &RHS) {
+ for (unsigned I = 0, E = array_lengthof(Bits); I != E; ++I) {
+ Bits[I] |= RHS.Bits[I];
+ }
+ return *this;
+ }
+ constexpr FeatureBitset operator|(const FeatureBitset &RHS) const {
+ FeatureBitset Result = *this;
+ Result |= RHS;
+ return Result;
+ }
+
+ constexpr FeatureBitset operator~() const {
+ FeatureBitset Result = *this;
+ for (auto &B : Result.Bits)
+ B = ~B;
+ return Result;
+ }
+
+ bool operator==(const FeatureBitset &RHS) const {
+ return std::equal(std::begin(Bits), std::end(Bits), std::begin(RHS.Bits));
+ }
+
+ bool operator!=(const FeatureBitset &RHS) const { return !(*this == RHS); }
+
bool operator < (const FeatureBitset &Other) const {
for (unsigned I = 0, E = size(); I != E; ++I) {
bool LHS = test(I), RHS = Other.test(I);
@@ -58,23 +162,12 @@
};
/// Class used to store the subtarget bits in the tables created by tablegen.
-/// The std::initializer_list constructor of FeatureBitset can't be done at
-/// compile time and requires a static constructor to run at startup.
-class FeatureBitArray {
- std::array<uint64_t, MAX_SUBTARGET_WORDS> Bits;
-
+class FeatureBitArray : public FeatureBitset {
public:
constexpr FeatureBitArray(const std::array<uint64_t, MAX_SUBTARGET_WORDS> &B)
- : Bits(B) {}
+ : FeatureBitset(B) {}
- FeatureBitset getAsBitset() const {
- FeatureBitset Result;
-
- for (unsigned i = 0, e = Bits.size(); i != e; ++i)
- Result |= FeatureBitset(Bits[i]) << (64 * i);
-
- return Result;
- }
+ const FeatureBitset &getAsBitset() const { return *this; }
};
//===----------------------------------------------------------------------===//
@@ -121,7 +214,7 @@
}
/// Return string stripped of flag.
- static std::string StripFlag(StringRef Feature) {
+ static StringRef StripFlag(StringRef Feature) {
return hasFlag(Feature) ? Feature.substr(1) : Feature;
}