RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 03:02:36 +01:00
Code Issues Projects Releases Wiki Activity

[MC] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).

Browse Source 
llvm-svn: 294813
This commit is contained in:
Eugene Zelenko 2017-02-11 00:27:28 +00:00
parent 63a2ffaff0
commit f7c046da8b
21 changed files with 258 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
include/llvm/MC/MCAsmInfo.h
View File

@ -16,20 +16,22 @@
#ifndef LLVM_MC_MCASMINFO_H
#define LLVM_MC_MCASMINFO_H
#include "llvm/ADT/StringRef.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCDwarf.h"
#include "llvm/MC/MCTargetOptions.h"
#include <cassert>
#include <vector>
namespace llvm {
class MCContext;
class MCExpr;
class MCSection;
class MCStreamer;
class MCSymbol;
class MCContext;
namespace WinEH {
enum class EncodingType {
Invalid, /// Invalid
Alpha, /// Windows Alpha
@ -40,11 +42,14 @@ enum class EncodingType {
X86, /// Windows x86, uses no CFI, just EH tables
MIPS = Alpha,
};
}
} // end namespace WinEH
namespace LCOMM {
enum LCOMMType { NoAlignment, ByteAlignment, Log2Alignment };
}
} // end namespace LCOMM
enum class DebugCompressionType {
DCT_None, // no compression
@ -61,41 +66,41 @@ protected:
//
/// Pointer size in bytes. Default is 4.
unsigned PointerSize;
unsigned PointerSize = 4;
/// Size of the stack slot reserved for callee-saved registers, in bytes.
/// Default is same as pointer size.
unsigned CalleeSaveStackSlotSize;
unsigned CalleeSaveStackSlotSize = 4;
/// True if target is little endian. Default is true.
bool IsLittleEndian;
bool IsLittleEndian = true;
/// True if target stack grow up. Default is false.
bool StackGrowsUp;
bool StackGrowsUp = false;
/// True if this target has the MachO .subsections_via_symbols directive.
/// Default is false.
bool HasSubsectionsViaSymbols;
bool HasSubsectionsViaSymbols = false;
/// True if this is a MachO target that supports the macho-specific .zerofill
/// directive for emitting BSS Symbols. Default is false.
bool HasMachoZeroFillDirective;
bool HasMachoZeroFillDirective = false;
/// True if this is a MachO target that supports the macho-specific .tbss
/// directive for emitting thread local BSS Symbols. Default is false.
bool HasMachoTBSSDirective;
bool HasMachoTBSSDirective = 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;
unsigned MaxInstLength = 4;
/// Every possible instruction length is a multiple of this value. Factored
/// out in .debug_frame and .debug_line. Defaults to 1.
unsigned MinInstAlignment;
unsigned MinInstAlignment = 1;
/// The '$' token, when not referencing an identifier or constant, refers to
/// the current PC. Defaults to false.
bool DollarIsPC;
bool DollarIsPC = false;
/// This string, if specified, is used to separate instructions from each
/// other when on the same line. Defaults to ';'
@ -109,10 +114,10 @@ protected:
const char *LabelSuffix;
// Print the EH begin symbol with an assignment. Defaults to false.
bool UseAssignmentForEHBegin;
bool UseAssignmentForEHBegin = false;
// Do we need to create a local symbol for .size?
bool NeedsLocalForSize;
bool NeedsLocalForSize = false;
/// This prefix is used for globals like constant pool entries that are
/// completely private to the .s file and should not have names in the .o
@ -142,20 +147,20 @@ protected:
const char *Code64Directive;
/// Which dialect of an assembler variant to use. Defaults to 0
unsigned AssemblerDialect;
unsigned AssemblerDialect = 0;
/// This is true if the assembler allows @ characters in symbol names.
/// Defaults to false.
bool AllowAtInName;
bool AllowAtInName = false;
/// If this is true, symbol names with invalid characters will be printed in
/// quotes.
bool SupportsQuotedNames;
bool SupportsQuotedNames = true;
/// This is true if data region markers should be printed as
/// ".data_region/.end_data_region" directives. If false, use "$d/$a" labels
/// instead.
bool UseDataRegionDirectives;
bool UseDataRegionDirectives = false;
//===--- Data Emission Directives -------------------------------------===//
@ -185,13 +190,13 @@ protected:
/// 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 NULL.
const char *GPRel64Directive;
/// to nullptr.
const char *GPRel64Directive = nullptr;
/// If non-null, a directive that is used to emit a word which should be
/// relocated as a 32-bit GP-relative offset, e.g. .gpword on Mips or .gprel32
/// on Alpha. Defaults to NULL.
const char *GPRel32Directive;
/// on Alpha. Defaults to nullptr.
const char *GPRel32Directive = nullptr;
/// If non-null, directives that are used to emit a word/dword which should
/// be relocated as a 32/64-bit DTP/TP-relative offset, e.g. .dtprelword/
@ -204,14 +209,14 @@ protected:
/// This is true if this target uses "Sun Style" syntax for section switching
/// ("#alloc,#write" etc) instead of the normal ELF syntax (,"a,w") in
/// .section directives. Defaults to false.
bool SunStyleELFSectionSwitchSyntax;
bool SunStyleELFSectionSwitchSyntax = false;
/// This is true if this target uses ELF '.section' directive before the
/// '.bss' one. It's used for PPC/Linux which doesn't support the '.bss'
/// directive only. Defaults to false.
bool UsesELFSectionDirectiveForBSS;
bool UsesELFSectionDirectiveForBSS = false;
bool NeedsDwarfSectionOffsetDirective;
bool NeedsDwarfSectionOffsetDirective = false;
//===--- Alignment Information ----------------------------------------===//
@ -219,11 +224,11 @@ protected:
/// directives, where N is the number of bytes to align to. Otherwise, it
/// emits ".align log2(N)", e.g. 3 to align to an 8 byte boundary. Defaults
/// to true.
bool AlignmentIsInBytes;
bool AlignmentIsInBytes = true;
/// If non-zero, this is used to fill the executable space created as the
/// result of a alignment directive. Defaults to 0
unsigned TextAlignFillValue;
unsigned TextAlignFillValue = 0;
//===--- Global Variable Emission Directives --------------------------===//
@ -236,7 +241,7 @@ protected:
/// uses a relocation but it can be suppressed by writing
/// a = f - g
/// .long a
bool SetDirectiveSuppressesReloc;
bool SetDirectiveSuppressesReloc = false;
/// False if the assembler requires that we use
/// \code
@ -251,98 +256,98 @@ protected:
/// \endcode
///
/// Defaults to true.
bool HasAggressiveSymbolFolding;
bool HasAggressiveSymbolFolding = true;
/// True is .comm's and .lcomms optional alignment is to be specified in bytes
/// instead of log2(n). Defaults to true.
bool COMMDirectiveAlignmentIsInBytes;
bool COMMDirectiveAlignmentIsInBytes = true;
/// Describes if the .lcomm directive for the target supports an alignment
/// argument and how it is interpreted. Defaults to NoAlignment.
LCOMM::LCOMMType LCOMMDirectiveAlignmentType;
LCOMM::LCOMMType LCOMMDirectiveAlignmentType = LCOMM::NoAlignment;
// True if the target allows .align directives on functions. This is true for
// most targets, so defaults to true.
bool HasFunctionAlignment;
bool HasFunctionAlignment = true;
/// True if the target has .type and .size directives, this is true for most
/// ELF targets. Defaults to true.
bool HasDotTypeDotSizeDirective;
bool HasDotTypeDotSizeDirective = true;
/// True if the target has a single parameter .file directive, this is true
/// for ELF targets. Defaults to true.
bool HasSingleParameterDotFile;
bool HasSingleParameterDotFile = true;
/// True if the target has a .ident directive, this is true for ELF targets.
/// Defaults to false.
bool HasIdentDirective;
bool HasIdentDirective = false;
/// True if this target supports the MachO .no_dead_strip directive. Defaults
/// to false.
bool HasNoDeadStrip;
bool HasNoDeadStrip = false;
/// True if this target supports the MachO .alt_entry directive. Defaults to
/// false.
bool HasAltEntry;
bool HasAltEntry = false;
/// Used to declare a global as being a weak symbol. Defaults to ".weak".
const char *WeakDirective;
/// This directive, if non-null, is used to declare a global as being a weak
/// undefined symbol. Defaults to NULL.
const char *WeakRefDirective;
/// undefined symbol. Defaults to nullptr.
const char *WeakRefDirective = nullptr;
/// True if we have a directive to declare a global as being a weak defined
/// symbol. Defaults to false.
bool HasWeakDefDirective;
bool HasWeakDefDirective = false;
/// True if we have a directive to declare a global as being a weak defined
/// symbol that can be hidden (unexported). Defaults to false.
bool HasWeakDefCanBeHiddenDirective;
bool HasWeakDefCanBeHiddenDirective = false;
/// True if we have a .linkonce directive. This is used on cygwin/mingw.
/// Defaults to false.
bool HasLinkOnceDirective;
bool HasLinkOnceDirective = false;
/// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
/// hidden visibility. Defaults to MCSA_Hidden.
MCSymbolAttr HiddenVisibilityAttr;
MCSymbolAttr HiddenVisibilityAttr = MCSA_Hidden;
/// This attribute, if not MCSA_Invalid, is used to declare an undefined
/// symbol as having hidden visibility. Defaults to MCSA_Hidden.
MCSymbolAttr HiddenDeclarationVisibilityAttr;
MCSymbolAttr HiddenDeclarationVisibilityAttr = MCSA_Hidden;
/// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
/// protected visibility. Defaults to MCSA_Protected
MCSymbolAttr ProtectedVisibilityAttr;
MCSymbolAttr ProtectedVisibilityAttr = MCSA_Protected;
//===--- Dwarf Emission Directives -----------------------------------===//
/// True if target supports emission of debugging information. Defaults to
/// false.
bool SupportsDebugInformation;
bool SupportsDebugInformation = false;
/// Exception handling format for the target. Defaults to None.
ExceptionHandling ExceptionsType;
ExceptionHandling ExceptionsType = ExceptionHandling::None;
/// Windows exception handling data (.pdata) encoding. Defaults to Invalid.
WinEH::EncodingType WinEHEncodingType;
WinEH::EncodingType WinEHEncodingType = WinEH::EncodingType::Invalid;
/// True if Dwarf2 output generally uses relocations for references to other
/// .debug_* sections.
bool DwarfUsesRelocationsAcrossSections;
bool DwarfUsesRelocationsAcrossSections = true;
/// True if DWARF FDE symbol reference relocations should be replaced by an
/// absolute difference.
bool DwarfFDESymbolsUseAbsDiff;
bool DwarfFDESymbolsUseAbsDiff = false;
/// True if dwarf register numbers are printed instead of symbolic register
/// names in .cfi_* directives. Defaults to false.
bool DwarfRegNumForCFI;
bool DwarfRegNumForCFI = false;
/// True if target uses parens to indicate the symbol variant instead of @.
/// For example, foo(plt) instead of foo@plt. Defaults to false.
bool UseParensForSymbolVariant;
bool UseParensForSymbolVariant = false;
//===--- Prologue State ----------------------------------------------===//
@ -361,11 +366,11 @@ protected:
bool PreserveAsmComments;
/// Compress DWARF debug sections. Defaults to no compression.
DebugCompressionType CompressDebugSections;
DebugCompressionType CompressDebugSections = DebugCompressionType::DCT_None;
/// True if the integrated assembler should interpret 'a >> b' constant
/// expressions as logical rather than arithmetic.
bool UseLogicalShr;
bool UseLogicalShr = true;
// If true, emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL, on
// X86_64 ELF.
@ -475,14 +480,17 @@ public:
bool needsLocalForSize() const { return NeedsLocalForSize; }
StringRef getPrivateGlobalPrefix() const { return PrivateGlobalPrefix; }
StringRef getPrivateLabelPrefix() const { return PrivateLabelPrefix; }
bool hasLinkerPrivateGlobalPrefix() const {
return LinkerPrivateGlobalPrefix[0] != '\0';
}
StringRef getLinkerPrivateGlobalPrefix() const {
if (hasLinkerPrivateGlobalPrefix())
return LinkerPrivateGlobalPrefix;
return getPrivateGlobalPrefix();
}
const char *getInlineAsmStart() const { return InlineAsmStart; }
const char *getInlineAsmEnd() const { return InlineAsmEnd; }
const char *getCode16Directive() const { return Code16Directive; }
@ -491,25 +499,32 @@ public:
unsigned getAssemblerDialect() const { return AssemblerDialect; }
bool doesAllowAtInName() const { return AllowAtInName; }
bool supportsNameQuoting() const { return SupportsQuotedNames; }
bool doesSupportDataRegionDirectives() const {
return UseDataRegionDirectives;
}
const char *getZeroDirective() const { return ZeroDirective; }
const char *getAsciiDirective() const { return AsciiDirective; }
const char *getAscizDirective() const { return AscizDirective; }
bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; }
unsigned getTextAlignFillValue() const { return TextAlignFillValue; }
const char *getGlobalDirective() const { return GlobalDirective; }
bool doesSetDirectiveSuppressReloc() const {
return SetDirectiveSuppressesReloc;
}
bool hasAggressiveSymbolFolding() const { return HasAggressiveSymbolFolding; }
bool getCOMMDirectiveAlignmentIsInBytes() const {
return COMMDirectiveAlignmentIsInBytes;
}
LCOMM::LCOMMType getLCOMMDirectiveAlignmentType() const {
return LCOMMDirectiveAlignmentType;
}
bool hasFunctionAlignment() const { return HasFunctionAlignment; }
bool hasDotTypeDotSizeDirective() const { return HasDotTypeDotSizeDirective; }
bool hasSingleParameterDotFile() const { return HasSingleParameterDotFile; }
@ -519,22 +534,29 @@ public:
const char *getWeakDirective() const { return WeakDirective; }
const char *getWeakRefDirective() const { return WeakRefDirective; }
bool hasWeakDefDirective() const { return HasWeakDefDirective; }
bool hasWeakDefCanBeHiddenDirective() const {
return HasWeakDefCanBeHiddenDirective;
}
bool hasLinkOnceDirective() const { return HasLinkOnceDirective; }
MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; }
MCSymbolAttr getHiddenDeclarationVisibilityAttr() const {
return HiddenDeclarationVisibilityAttr;
}
MCSymbolAttr getProtectedVisibilityAttr() const {
return ProtectedVisibilityAttr;
}
bool doesSupportDebugInformation() const { return SupportsDebugInformation; }
bool doesSupportExceptionHandling() const {
return ExceptionsType != ExceptionHandling::None;
}
ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; }
WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; }
@ -558,6 +580,7 @@ public:
bool doesDwarfUseRelocationsAcrossSections() const {
return DwarfUsesRelocationsAcrossSections;
}
bool doDwarfFDESymbolsUseAbsDiff() const { return DwarfFDESymbolsUseAbsDiff; }
bool useDwarfRegNumForCFI() const { return DwarfRegNumForCFI; }
bool useParensForSymbolVariant() const { return UseParensForSymbolVariant; }
@ -600,6 +623,7 @@ public:
void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; }
bool hasMipsExpressions() const { return HasMipsExpressions; }
};
}
#endif
} // end namespace llvm
#endif // LLVM_MC_MCASMINFO_H

28
include/llvm/MC/MCAsmInfoCOFF.h
View File

@ -1,4 +1,4 @@
//===-- MCAsmInfoCOFF.h - COFF asm properties -------------------*- C++ -*-===//
//===- MCAsmInfoCOFF.h - COFF asm properties --------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -13,24 +13,28 @@
#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class MCAsmInfoCOFF : public MCAsmInfo {
class MCAsmInfoCOFF : public MCAsmInfo {
virtual void anchor();
protected:
protected:
explicit MCAsmInfoCOFF();
};
};
class MCAsmInfoMicrosoft : public MCAsmInfoCOFF {
class MCAsmInfoMicrosoft : public MCAsmInfoCOFF {
void anchor() override;
protected:
protected:
explicit MCAsmInfoMicrosoft();
};
};
class MCAsmInfoGNUCOFF : public MCAsmInfoCOFF {
class MCAsmInfoGNUCOFF : public MCAsmInfoCOFF {
void anchor() override;
protected:
explicit MCAsmInfoGNUCOFF();
};
}
protected:
explicit MCAsmInfoGNUCOFF();
};
} // end namespace llvm
#endif // LLVM_MC_MCASMINFOCOFF_H

16
include/llvm/MC/MCAsmInfoDarwin.h
View File

@ -1,4 +1,4 @@
//===---- MCAsmInfoDarwin.h - Darwin asm properties -------------*- C++ -*-===//
//===- MCAsmInfoDarwin.h - Darwin asm properties ----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -18,12 +18,14 @@
#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class MCAsmInfoDarwin : public MCAsmInfo {
public:
explicit MCAsmInfoDarwin();
bool isSectionAtomizableBySymbols(const MCSection &Section) const override;
};
}
class MCAsmInfoDarwin : public MCAsmInfo {
public:
explicit MCAsmInfoDarwin();
bool isSectionAtomizableBySymbols(const MCSection &Section) const override;
};
} // end namespace llvm
#endif // LLVM_MC_MCASMINFODARWIN_H

10
include/llvm/MC/MCAsmInfoELF.h
View File

@ -1,4 +1,4 @@
//===-- llvm/MC/MCAsmInfoELF.h - ELF Asm info -------------------*- C++ -*-===//
//===- llvm/MC/MCAsmInfoELF.h - ELF Asm info --------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -13,6 +13,7 @@
#include "llvm/MC/MCAsmInfo.h"
namespace llvm {
class MCAsmInfoELF : public MCAsmInfo {
virtual void anchor();
MCSection *getNonexecutableStackSection(MCContext &Ctx) const final;
@ -20,10 +21,11 @@ class MCAsmInfoELF : public MCAsmInfo {
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;
bool UsesNonexecutableStackSection = true;
MCAsmInfoELF();
};
}
#endif
} // end namespace llvm
#endif // LLVM_MC_MCASMINFOELF_H

30
include/llvm/MC/MCInst.h
View File

@ -1,4 +1,4 @@
//===-- llvm/MC/MCInst.h - MCInst class -------------------------*- C++ -*-===//
//===- llvm/MC/MCInst.h - MCInst class --------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -18,15 +18,17 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/SMLoc.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
namespace llvm {
class raw_ostream;
class MCAsmInfo;
class MCInstPrinter;
class MCExpr;
class MCInst;
class MCInstPrinter;
class raw_ostream;
/// \brief Instances of this class represent operands of the MCInst class.
/// This is a simple discriminated union.
@ -39,7 +41,7 @@ class MCOperand {
kExpr, ///< Relocatable immediate operand.
kInst ///< Sub-instruction operand.
};
MachineOperandType Kind;
MachineOperandType Kind = kInvalid;
union {
unsigned RegVal;
@ -50,7 +52,7 @@ class MCOperand {
};
public:
MCOperand() : Kind(kInvalid), FPImmVal(0.0) {}
MCOperand() : FPImmVal(0.0) {}
bool isValid() const { return Kind != kInvalid; }
bool isReg() const { return Kind == kRegister; }
@ -75,6 +77,7 @@ public:
assert(isImm() && "This is not an immediate");
return ImmVal;
}
void setImm(int64_t Val) {
assert(isImm() && "This is not an immediate");
ImmVal = Val;
@ -94,6 +97,7 @@ public:
assert(isExpr() && "This is not an expression");
return ExprVal;
}
void setExpr(const MCExpr *Val) {
assert(isExpr() && "This is not an expression");
ExprVal = Val;
@ -103,6 +107,7 @@ public:
assert(isInst() && "This is not a sub-instruction");
return InstVal;
}
void setInst(const MCInst *Val) {
assert(isInst() && "This is not a sub-instruction");
InstVal = Val;
@ -114,24 +119,28 @@ public:
Op.RegVal = Reg;
return Op;
}
static MCOperand createImm(int64_t Val) {
MCOperand Op;
Op.Kind = kImmediate;
Op.ImmVal = Val;
return Op;
}
static MCOperand createFPImm(double Val) {
MCOperand Op;
Op.Kind = kFPImmediate;
Op.FPImmVal = Val;
return Op;
}
static MCOperand createExpr(const MCExpr *Val) {
MCOperand Op;
Op.Kind = kExpr;
Op.ExprVal = Val;
return Op;
}
static MCOperand createInst(const MCInst *Val) {
MCOperand Op;
Op.Kind = kInst;
@ -148,12 +157,12 @@ template <> struct isPodLike<MCOperand> { static const bool value = true; };
/// \brief Instances of this class represent a single low-level machine
/// instruction.
class MCInst {
unsigned Opcode;
unsigned Opcode = 0;
SMLoc Loc;
SmallVector<MCOperand, 8> Operands;
public:
MCInst() : Opcode(0) {}
MCInst() = default;
void setOpcode(unsigned Op) { Opcode = Op; }
unsigned getOpcode() const { return Opcode; }
@ -176,6 +185,7 @@ public:
const_iterator begin() const { return Operands.begin(); }
iterator end() { return Operands.end(); }
const_iterator end() const { return Operands.end(); }
iterator insert(iterator I, const MCOperand &Op) {
return Operands.insert(I, Op);
}
@ -202,4 +212,4 @@ inline raw_ostream& operator<<(raw_ostream &OS, const MCInst &MI) {
} // end namespace llvm
#endif
#endif // LLVM_MC_MCINST_H

16
include/llvm/MC/MCInstPrinter.h
View File

@ -16,12 +16,12 @@
namespace llvm {
template <typename T> class ArrayRef;
class MCInst;
class raw_ostream;
class MCAsmInfo;
class MCInst;
class MCInstrInfo;
class MCRegisterInfo;
class MCSubtargetInfo;
class raw_ostream;
class StringRef;
/// Convert `Bytes' to a hex string and output to `OS'
@ -43,28 +43,26 @@ protected:
/// \brief A stream that comments can be emitted to if desired. Each comment
/// must end with a newline. This will be null if verbose assembly emission
/// is disable.
raw_ostream *CommentStream;
raw_ostream *CommentStream = nullptr;
const MCAsmInfo &MAI;
const MCInstrInfo &MII;
const MCRegisterInfo &MRI;
/// True if we are printing marked up assembly.
bool UseMarkup;
bool UseMarkup = false;
/// True if we are printing immediates as hex.
bool PrintImmHex;
bool PrintImmHex = false;
/// Which style to use for printing hexadecimal values.
HexStyle::Style PrintHexStyle;
HexStyle::Style PrintHexStyle = HexStyle::C;
/// Utility function for printing annotations.
void printAnnotation(raw_ostream &OS, StringRef Annot);
public:
MCInstPrinter(const MCAsmInfo &mai, const MCInstrInfo &mii,
const MCRegisterInfo &mri)
: CommentStream(nullptr), MAI(mai), MII(mii), MRI(mri), UseMarkup(false),
PrintImmHex(false), PrintHexStyle(HexStyle::C) {}
const MCRegisterInfo &mri) : MAI(mai), MII(mii), MRI(mri) {}
virtual ~MCInstPrinter();

11
include/llvm/MC/MCInstrAnalysis.h
View File

@ -1,4 +1,4 @@
//===-- llvm/MC/MCInstrAnalysis.h - InstrDesc target hooks ------*- C++ -*-===//
//===- llvm/MC/MCInstrAnalysis.h - InstrDesc target hooks -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -18,18 +18,19 @@
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrDesc.h"
#include "llvm/MC/MCInstrInfo.h"
#include <cstdint>
namespace llvm {
class MCInstrAnalysis {
protected:
friend class Target;
const MCInstrInfo *Info;
public:
MCInstrAnalysis(const MCInstrInfo *Info) : Info(Info) {}
virtual ~MCInstrAnalysis() {}
virtual ~MCInstrAnalysis() = default;
virtual bool isBranch(const MCInst &Inst) const {
return Info->get(Inst.getOpcode()).isBranch();
@ -66,6 +67,6 @@ public:
uint64_t &Target) const;
};
} // End llvm namespace
} // end namespace llvm
#endif
#endif // LLVM_MC_MCINSTRANALYSIS_H

26
include/llvm/MC/MCInstrItineraries.h
View File

@ -1,4 +1,4 @@
//===-- llvm/MC/MCInstrItineraries.h - Scheduling ---------------*- C++ -*-===//
//===- llvm/MC/MCInstrItineraries.h - Scheduling ----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -88,7 +88,6 @@ struct InstrStage {
}
};
//===----------------------------------------------------------------------===//
/// An itinerary represents the scheduling information for an instruction.
/// This includes a set of stages occupied by the instruction and the pipeline
@ -102,23 +101,20 @@ struct InstrItinerary {
unsigned LastOperandCycle; ///< Index of last + 1 operand rd/wr
};
//===----------------------------------------------------------------------===//
/// Itinerary data supplied by a subtarget to be used by a target.
///
class InstrItineraryData {
public:
MCSchedModel SchedModel; ///< Basic machine properties.
const InstrStage *Stages; ///< Array of stages selected
const unsigned *OperandCycles; ///< Array of operand cycles selected
const unsigned *Forwardings; ///< Array of pipeline forwarding paths
const InstrItinerary *Itineraries; ///< Array of itineraries selected
/// Ctors.
InstrItineraryData() : SchedModel(MCSchedModel::GetDefaultSchedModel()),
Stages(nullptr), OperandCycles(nullptr),
Forwardings(nullptr), Itineraries(nullptr) {}
MCSchedModel SchedModel =
MCSchedModel::GetDefaultSchedModel(); ///< Basic machine properties.
const InstrStage *Stages = nullptr; ///< Array of stages selected
const unsigned *OperandCycles = nullptr; ///< Array of operand cycles selected
const unsigned *Forwardings = nullptr; ///< Array of pipeline forwarding paths
const InstrItinerary *Itineraries =
nullptr; ///< Array of itineraries selected
InstrItineraryData() = default;
InstrItineraryData(const MCSchedModel &SM, const InstrStage *S,
const unsigned *OS, const unsigned *F)
: SchedModel(SM), Stages(S), OperandCycles(OS), Forwardings(F),
@ -234,6 +230,6 @@ public:
}
};
} // End llvm namespace
} // end namespace llvm
#endif
#endif // LLVM_MC_MCINSTRITINERARIES_H

11
include/llvm/MC/MCLinkerOptimizationHint.h
View File

@ -21,13 +21,14 @@
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <cstdint>
namespace llvm {
// Forward declarations.
class MachObjectWriter;
class MCAsmLayout;
class MCSymbol;
class MachObjectWriter;
/// Linker Optimization Hint Type.
enum MCLOHType {
@ -133,7 +134,7 @@ public:
class MCLOHContainer {
/// Keep track of the emit size of all the LOHs.
mutable uint64_t EmitSize;
mutable uint64_t EmitSize = 0;
/// Keep track of all LOH directives.
SmallVector<MCLOHDirective, 32> Directives;
@ -141,7 +142,7 @@ class MCLOHContainer {
public:
typedef SmallVectorImpl<MCLOHDirective> LOHDirectives;
MCLOHContainer() : EmitSize(0) {}
MCLOHContainer() = default;
/// Const accessor to the directives.
const LOHDirectives &getDirectives() const {
@ -183,4 +184,4 @@ typedef MCLOHContainer::LOHDirectives MCLOHDirectives;
} // end namespace llvm
#endif
#endif // LLVM_MC_MCLINKEROPTIMIZATIONHINT_H

11
include/llvm/MC/StringTableBuilder.h
View File

@ -1,4 +1,4 @@
//===-- StringTableBuilder.h - String table building utility ------*- C++ -*-=//
//===- StringTableBuilder.h - String table building utility -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -12,9 +12,12 @@
#include "llvm/ADT/CachedHashString.h"
#include "llvm/ADT/DenseMap.h"
#include <cassert>
#include "llvm/ADT/StringRef.h"
#include <cstddef>
#include <cstdint>
namespace llvm {
class raw_ostream;
/// \brief Utility for building string tables with deduplicated suffixes.
@ -67,6 +70,6 @@ private:
bool isFinalized() const { return Finalized; }
};
} // end llvm namespace
} // end namespace llvm
#endif
#endif // LLVM_MC_STRINGTABLEBUILDER_H

45
lib/MC/ELFObjectWriter.cpp
View File

@ -11,30 +11,49 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCELFObjectWriter.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/MC/MCAsmBackend.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCELFObjectWriter.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCFixupKindInfo.h"
#include "llvm/MC/MCFixup.h"
#include "llvm/MC/MCFragment.h"
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCSection.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCSymbolELF.h"
#include "llvm/MC/MCValue.h"
#include "llvm/MC/StringTableBuilder.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compression.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ELF.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/SMLoc.h"
#include "llvm/Support/StringSaver.h"
#include "llvm/Support/SwapByteOrder.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
using namespace llvm;
@ -43,6 +62,7 @@ using namespace llvm;
#define DEBUG_TYPE "reloc-info"
namespace {
typedef DenseMap<const MCSectionELF *, uint32_t> SectionIndexMapTy;
class ELFObjectWriter;
@ -100,8 +120,7 @@ class ELFObjectWriter : public MCObjectWriter {
DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;
llvm::DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>>
Relocations;
DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>> Relocations;
/// @}
/// @name Symbol Table Data
@ -145,6 +164,8 @@ public:
bool IsLittleEndian)
: MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(MOTW) {}
~ELFObjectWriter() override = default;
void reset() override {
Renames.clear();
Relocations.clear();
@ -153,8 +174,6 @@ public:
MCObjectWriter::reset();
}
~ELFObjectWriter() override;
void WriteWord(uint64_t W) {
if (is64Bit())
write64(W);
@ -235,6 +254,7 @@ public:
uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
const MCSectionELF &Section);
};
} // end anonymous namespace
void ELFObjectWriter::align(unsigned Alignment) {
@ -298,9 +318,6 @@ void SymbolTableWriter::writeSymbol(uint32_t name, uint8_t info, uint64_t value,
++NumWritten;
}
ELFObjectWriter::~ELFObjectWriter()
{}
// Emit the ELF header.
void ELFObjectWriter::writeHeader(const MCAssembler &Asm) {
// ELF Header

60
lib/MC/MCAsmInfo.cpp
View File

@ -1,4 +1,4 @@
//===-- MCAsmInfo.cpp - Asm Info -------------------------------------------==//
//===- MCAsmInfo.cpp - Asm Info -------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
@ -16,29 +16,14 @@
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Dwarf.h"
#include <cctype>
#include <cstring>
using namespace llvm;
MCAsmInfo::MCAsmInfo() {
PointerSize = 4;
CalleeSaveStackSlotSize = 4;
IsLittleEndian = true;
StackGrowsUp = false;
HasSubsectionsViaSymbols = false;
HasMachoZeroFillDirective = false;
HasMachoTBSSDirective = false;
MaxInstLength = 4;
MinInstAlignment = 1;
DollarIsPC = false;
SeparatorString = ";";
CommentString = "#";
LabelSuffix = ":";
UseAssignmentForEHBegin = false;
NeedsLocalForSize = false;
PrivateGlobalPrefix = "L";
PrivateLabelPrefix = PrivateGlobalPrefix;
LinkerPrivateGlobalPrefix = "";
@ -47,10 +32,6 @@ MCAsmInfo::MCAsmInfo() {
Code16Directive = ".code16";
Code32Directive = ".code32";
Code64Directive = ".code64";
AssemblerDialect = 0;
AllowAtInName = false;
SupportsQuotedNames = true;
UseDataRegionDirectives = false;
ZeroDirective = "\t.zero\t";
AsciiDirective = "\t.ascii\t";
AscizDirective = "\t.asciz\t";
@ -58,40 +39,8 @@ MCAsmInfo::MCAsmInfo() {
Data16bitsDirective = "\t.short\t";
Data32bitsDirective = "\t.long\t";
Data64bitsDirective = "\t.quad\t";
SunStyleELFSectionSwitchSyntax = false;
UsesELFSectionDirectiveForBSS = false;
AlignmentIsInBytes = true;
TextAlignFillValue = 0;
GPRel64Directive = nullptr;
GPRel32Directive = nullptr;
GlobalDirective = "\t.globl\t";
SetDirectiveSuppressesReloc = false;
HasAggressiveSymbolFolding = true;
COMMDirectiveAlignmentIsInBytes = true;
LCOMMDirectiveAlignmentType = LCOMM::NoAlignment;
HasFunctionAlignment = true;
HasDotTypeDotSizeDirective = true;
HasSingleParameterDotFile = true;
HasIdentDirective = false;
HasNoDeadStrip = false;
HasAltEntry = false;
WeakDirective = "\t.weak\t";
WeakRefDirective = nullptr;
HasWeakDefDirective = false;
HasWeakDefCanBeHiddenDirective = false;
HasLinkOnceDirective = false;
HiddenVisibilityAttr = MCSA_Hidden;
HiddenDeclarationVisibilityAttr = MCSA_Hidden;
ProtectedVisibilityAttr = MCSA_Protected;
SupportsDebugInformation = false;
ExceptionsType = ExceptionHandling::None;
WinEHEncodingType = WinEH::EncodingType::Invalid;
DwarfUsesRelocationsAcrossSections = true;
DwarfFDESymbolsUseAbsDiff = false;
DwarfRegNumForCFI = false;
NeedsDwarfSectionOffsetDirective = false;
UseParensForSymbolVariant = false;
UseLogicalShr = true;
// FIXME: Clang's logic should be synced with the logic used to initialize
// this member and the two implementations should be merged.
@ -107,12 +56,9 @@ MCAsmInfo::MCAsmInfo() {
// - The target subclasses for AArch64, ARM, and X86 handle these cases
UseIntegratedAssembler = false;
PreserveAsmComments = true;
CompressDebugSections = DebugCompressionType::DCT_None;
}
MCAsmInfo::~MCAsmInfo() {
}
MCAsmInfo::~MCAsmInfo() = default;
bool MCAsmInfo::isSectionAtomizableBySymbols(const MCSection &Section) const {
return false;

17
lib/MC/MCAsmInfoCOFF.cpp
View File

@ -1,4 +1,4 @@
//===-- MCAsmInfoCOFF.cpp - COFF asm properties -----------------*- C++ -*-===//
//===- MCAsmInfoCOFF.cpp - COFF asm properties ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
@ -13,9 +13,11 @@
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCAsmInfoCOFF.h"
#include "llvm/MC/MCDirectives.h"
using namespace llvm;
void MCAsmInfoCOFF::anchor() { }
void MCAsmInfoCOFF::anchor() {}
MCAsmInfoCOFF::MCAsmInfoCOFF() {
// MingW 4.5 and later support .comm with log2 alignment, but .lcomm uses byte
@ -41,13 +43,10 @@ MCAsmInfoCOFF::MCAsmInfoCOFF() {
UseLogicalShr = false;
}
void MCAsmInfoMicrosoft::anchor() { }
void MCAsmInfoMicrosoft::anchor() {}
MCAsmInfoMicrosoft::MCAsmInfoMicrosoft() {
}
MCAsmInfoMicrosoft::MCAsmInfoMicrosoft() = default;
void MCAsmInfoGNUCOFF::anchor() { }
void MCAsmInfoGNUCOFF::anchor() {}
MCAsmInfoGNUCOFF::MCAsmInfoGNUCOFF() {
}
MCAsmInfoGNUCOFF::MCAsmInfoGNUCOFF() = default;

7
lib/MC/MCAsmInfoDarwin.cpp
View File

@ -1,4 +1,4 @@
//===-- MCAsmInfoDarwin.cpp - Darwin asm properties -------------*- C++ -*-===//
//===- MCAsmInfoDarwin.cpp - Darwin asm properties ------------------------===//
//
// The LLVM Compiler Infrastructure
//
@ -13,9 +13,10 @@
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCAsmInfoDarwin.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/Support/MachO.h"
using namespace llvm;
bool MCAsmInfoDarwin::isSectionAtomizableBySymbols(

6
lib/MC/MCAsmInfoELF.cpp
View File

@ -1,4 +1,4 @@
//===-- MCAsmInfoELF.cpp - ELF asm properties -------------------*- C++ -*-===//
//===- MCAsmInfoELF.cpp - ELF asm properties ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
@ -16,9 +16,10 @@
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/Support/ELF.h"
using namespace llvm;
void MCAsmInfoELF::anchor() { }
void MCAsmInfoELF::anchor() {}
MCSection *MCAsmInfoELF::getNonexecutableStackSection(MCContext &Ctx) const {
if (!UsesNonexecutableStackSection)
@ -31,5 +32,4 @@ MCAsmInfoELF::MCAsmInfoELF() {
WeakRefDirective = "\t.weak\t";
PrivateGlobalPrefix = ".L";
PrivateLabelPrefix = ".L";
UsesNonexecutableStackSection = true;
}

1
lib/MC/MCInst.cpp
View File

@ -10,6 +10,7 @@
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInstPrinter.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"

13
lib/MC/MCInstPrinter.cpp
View File

@ -1,4 +1,4 @@
//===-- MCInstPrinter.cpp - Convert an MCInst to target assembly syntax ---===//
//===- MCInstPrinter.cpp - Convert an MCInst to target assembly syntax ----===//
//
// The LLVM Compiler Infrastructure
//
@ -7,13 +7,17 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCInstPrinter.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCInstPrinter.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include <cinttypes>
#include <cstdint>
using namespace llvm;
void llvm::dumpBytes(ArrayRef<uint8_t> bytes, raw_ostream &OS) {
@ -25,8 +29,7 @@ void llvm::dumpBytes(ArrayRef<uint8_t> bytes, raw_ostream &OS) {
}
}
MCInstPrinter::~MCInstPrinter() {
}
MCInstPrinter::~MCInstPrinter() = default;
/// getOpcodeName - Return the name of the specified opcode enum (e.g.
/// "MOV32ri") or empty if we can't resolve it.
@ -68,7 +71,7 @@ StringRef MCInstPrinter::markup(StringRef a, StringRef b) const {
// For asm-style hex (e.g. 0ffh) the first digit always has to be a number.
static bool needsLeadingZero(uint64_t Value)
{
while(Value)
while (Value)
{
uint64_t digit = (Value >> 60) & 0xf;
if (digit != 0)

7
lib/MC/MCInstrAnalysis.cpp
View File

@ -1,4 +1,4 @@
//===-- MCInstrAnalysis.cpp - InstrDesc target hooks ------------*- C++ -*-===//
//===- MCInstrAnalysis.cpp - InstrDesc target hooks -----------------------===//
//
// The LLVM Compiler Infrastructure
//
@ -7,7 +7,12 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrAnalysis.h"
#include "llvm/MC/MCInstrDesc.h"
#include "llvm/MC/MCInstrInfo.h"
#include <cstdint>
using namespace llvm;
bool MCInstrAnalysis::evaluateBranch(const MCInst &Inst, uint64_t Addr,

10
lib/MC/MCLinkerOptimizationHint.cpp
View File

@ -1,4 +1,4 @@
//===-- llvm/MC/MCLinkerOptimizationHint.cpp ----- LOH handling -*- C++ -*-===//
//===- llvm/MC/MCLinkerOptimizationHint.cpp ----- LOH handling ------------===//
//
// The LLVM Compiler Infrastructure
//
@ -9,9 +9,11 @@
#include "llvm/MC/MCLinkerOptimizationHint.h"
#include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCMachObjectWriter.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/raw_ostream.h"
#include <cstddef>
#include <cstdint>
using namespace llvm;
@ -41,14 +43,14 @@ void MCLOHDirective::emit(MachObjectWriter &ObjWriter,
uint64_t MCLOHDirective::getEmitSize(const MachObjectWriter &ObjWriter,
const MCAsmLayout &Layout) const {
class raw_counting_ostream : public raw_ostream {
uint64_t Count;
uint64_t Count = 0;
void write_impl(const char *, size_t size) override { Count += size; }
uint64_t current_pos() const override { return Count; }
public:
raw_counting_ostream() : Count(0) {}
raw_counting_ostream() = default;
~raw_counting_ostream() override { flush(); }
};

4
lib/MC/MCMachObjectTargetWriter.cpp
View File

@ -1,4 +1,4 @@
//===-- MCMachObjectTargetWriter.cpp - Mach-O Target Writer Subclass ------===//
//===- MCMachObjectTargetWriter.cpp - Mach-O Target Writer Subclass -------===//
//
// The LLVM Compiler Infrastructure
//
@ -16,4 +16,4 @@ MCMachObjectTargetWriter::MCMachObjectTargetWriter(bool Is64Bit_,
uint32_t CPUSubtype_)
: Is64Bit(Is64Bit_), CPUType(CPUType_), CPUSubtype(CPUSubtype_) {}
MCMachObjectTargetWriter::~MCMachObjectTargetWriter() {}
MCMachObjectTargetWriter::~MCMachObjectTargetWriter() = default;

16
lib/MC/StringTableBuilder.cpp
View File

@ -1,4 +1,4 @@
//===-- StringTableBuilder.cpp - String table building utility ------------===//
//===- StringTableBuilder.cpp - String table building utility -------------===//
//
// The LLVM Compiler Infrastructure
//
@ -7,18 +7,24 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/StringTableBuilder.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/CachedHashString.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/MC/StringTableBuilder.h"
#include "llvm/Support/COFF.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <utility>
#include <vector>
using namespace llvm;
StringTableBuilder::~StringTableBuilder() {}
StringTableBuilder::~StringTableBuilder() = default;
void StringTableBuilder::initSize() {
// Account for leading bytes in table so that offsets returned from add are