6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-06-09 23:29:52 +00:00
Code Issues Projects Releases Wiki Activity

Fix uses of reserved identifiers starting with an underscore followed by an uppercase letter

Browse Source 
This covers essentially all of llvm's headers and libs. One or two weird
cases I wasn't sure were worth/appropriate to fix.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232394 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Blaikie 2015-03-16 18:06:57 +00:00
parent ed7120e7fd
commit 7610ba7d24
40 changed files with 171 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/CodeGen/LivePhysRegs.h
View File

@ -57,9 +57,9 @@ public:
}
/// \brief Clear and initialize the LivePhysRegs set.
void init(const TargetRegisterInfo *_TRI) {
assert(_TRI && "Invalid TargetRegisterInfo pointer.");
TRI = _TRI;
void init(const TargetRegisterInfo *TRI) {
assert(TRI && "Invalid TargetRegisterInfo pointer.");
this->TRI = TRI;
LiveRegs.clear();
LiveRegs.setUniverse(TRI->getNumRegs());
}

17
include/llvm/IR/InstIterator.h
View File

@ -27,15 +27,14 @@ namespace llvm {
// This class implements inst_begin() & inst_end() for
// inst_iterator and const_inst_iterator's.
//
template <class _BB_t, class _BB_i_t, class _BI_t, class _II_t>
class InstIterator {
typedef _BB_t BBty;
typedef _BB_i_t BBIty;
typedef _BI_t BIty;
typedef _II_t IIty;
_BB_t *BBs; // BasicBlocksType
_BB_i_t BB; // BasicBlocksType::iterator
_BI_t BI; // BasicBlock::iterator
template <class BB_t, class BB_i_t, class BI_t, class II_t> class InstIterator {
typedef BB_t BBty;
typedef BB_i_t BBIty;
typedef BI_t BIty;
typedef II_t IIty;
BB_t *BBs; // BasicBlocksType
BB_i_t BB; // BasicBlocksType::iterator
BI_t BI; // BasicBlock::iterator
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef IIty value_type;

2
include/llvm/MC/MCAsmLayout.h
View File

@ -56,7 +56,7 @@ private:
uint64_t FOffset, uint64_t FSize);
public:
MCAsmLayout(MCAssembler &_Assembler);
MCAsmLayout(MCAssembler &Assembler);
/// Get the assembler object this is a layout for.
MCAssembler &getAssembler() const { return Assembler; }

48
include/llvm/MC/MCAssembler.h
View File

@ -88,7 +88,7 @@ private:
/// @}
protected:
MCFragment(FragmentType _Kind, MCSectionData *_Parent = nullptr);
MCFragment(FragmentType Kind, MCSectionData *Parent = nullptr);
public:
// Only for sentinel.
@ -307,11 +307,9 @@ class MCRelaxableFragment : public MCEncodedFragmentWithFixups {
SmallVector<MCFixup, 1> Fixups;
public:
MCRelaxableFragment(const MCInst &_Inst,
const MCSubtargetInfo &_STI,
MCRelaxableFragment(const MCInst &Inst, const MCSubtargetInfo &STI,
MCSectionData *SD = nullptr)
: MCEncodedFragmentWithFixups(FT_Relaxable, SD), Inst(_Inst), STI(_STI) {
}
: MCEncodedFragmentWithFixups(FT_Relaxable, SD), Inst(Inst), STI(STI) {}
SmallVectorImpl<char> &getContents() override { return Contents; }
const SmallVectorImpl<char> &getContents() const override { return Contents; }
@ -364,11 +362,10 @@ class MCAlignFragment : public MCFragment {
bool EmitNops : 1;
public:
MCAlignFragment(unsigned _Alignment, int64_t _Value, unsigned _ValueSize,
unsigned _MaxBytesToEmit, MCSectionData *SD = nullptr)
: MCFragment(FT_Align, SD), Alignment(_Alignment),
Value(_Value),ValueSize(_ValueSize),
MaxBytesToEmit(_MaxBytesToEmit), EmitNops(false) {}
MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize,
unsigned MaxBytesToEmit, MCSectionData *SD = nullptr)
: MCFragment(FT_Align, SD), Alignment(Alignment), Value(Value),
ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit), EmitNops(false) {}
/// @name Accessors
/// @{
@ -405,10 +402,10 @@ class MCFillFragment : public MCFragment {
uint64_t Size;
public:
MCFillFragment(int64_t _Value, unsigned _ValueSize, uint64_t _Size,
MCFillFragment(int64_t Value, unsigned ValueSize, uint64_t Size,
MCSectionData *SD = nullptr)
: MCFragment(FT_Fill, SD),
Value(_Value), ValueSize(_ValueSize), Size(_Size) {
: MCFragment(FT_Fill, SD), Value(Value), ValueSize(ValueSize),
Size(Size) {
assert((!ValueSize || (Size % ValueSize) == 0) &&
"Fill size must be a multiple of the value size!");
}
@ -439,10 +436,8 @@ class MCOrgFragment : public MCFragment {
int8_t Value;
public:
MCOrgFragment(const MCExpr &_Offset, int8_t _Value,
MCSectionData *SD = nullptr)
: MCFragment(FT_Org, SD),
Offset(&_Offset), Value(_Value) {}
MCOrgFragment(const MCExpr &Offset, int8_t Value, MCSectionData *SD = nullptr)
: MCFragment(FT_Org, SD), Offset(&Offset), Value(Value) {}
/// @name Accessors
/// @{
@ -505,10 +500,11 @@ class MCDwarfLineAddrFragment : public MCFragment {
SmallString<8> Contents;
public:
MCDwarfLineAddrFragment(int64_t _LineDelta, const MCExpr &_AddrDelta,
MCSectionData *SD = nullptr)
: MCFragment(FT_Dwarf, SD),
LineDelta(_LineDelta), AddrDelta(&_AddrDelta) { Contents.push_back(0); }
MCDwarfLineAddrFragment(int64_t LineDelta, const MCExpr &AddrDelta,
MCSectionData *SD = nullptr)
: MCFragment(FT_Dwarf, SD), LineDelta(LineDelta), AddrDelta(&AddrDelta) {
Contents.push_back(0);
}
/// @name Accessors
/// @{
@ -537,10 +533,10 @@ class MCDwarfCallFrameFragment : public MCFragment {
SmallString<8> Contents;
public:
MCDwarfCallFrameFragment(const MCExpr &_AddrDelta,
MCSectionData *SD = nullptr)
: MCFragment(FT_DwarfFrame, SD),
AddrDelta(&_AddrDelta) { Contents.push_back(0); }
MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSectionData *SD = nullptr)
: MCFragment(FT_DwarfFrame, SD), AddrDelta(&AddrDelta) {
Contents.push_back(0);
}
/// @name Accessors
/// @{
@ -722,7 +718,7 @@ class MCSymbolData : public ilist_node<MCSymbolData> {
public:
// Only for use as sentinel.
MCSymbolData();
MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment, uint64_t _Offset,
MCSymbolData(const MCSymbol &Symbol, MCFragment *Fragment, uint64_t Offset,
MCAssembler *A = nullptr);
/// @name Accessors

14
include/llvm/MC/MCExpr.h
View File

@ -56,7 +56,7 @@ private:
const SectionAddrMap *Addrs, bool InSet) const;
protected:
explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {}
explicit MCExpr(ExprKind Kind) : Kind(Kind) {}
bool EvaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
const MCAsmLayout *Layout,
@ -133,8 +133,8 @@ inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) {
class MCConstantExpr : public MCExpr {
int64_t Value;
explicit MCConstantExpr(int64_t _Value)
: MCExpr(MCExpr::Constant), Value(_Value) {}
explicit MCConstantExpr(int64_t Value)
: MCExpr(MCExpr::Constant), Value(Value) {}
public:
/// @name Construction
@ -354,8 +354,8 @@ private:
Opcode Op;
const MCExpr *Expr;
MCUnaryExpr(Opcode _Op, const MCExpr *_Expr)
: MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {}
MCUnaryExpr(Opcode Op, const MCExpr *Expr)
: MCExpr(MCExpr::Unary), Op(Op), Expr(Expr) {}
public:
/// @name Construction
@ -425,8 +425,8 @@ private:
Opcode Op;
const MCExpr *LHS, *RHS;
MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS)
: MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {}
MCBinaryExpr(Opcode Op, const MCExpr *LHS, const MCExpr *RHS)
: MCExpr(MCExpr::Binary), Op(Op), LHS(LHS), RHS(RHS) {}
public:
/// @name Construction

7
include/llvm/MC/MCMachObjectWriter.h
View File

@ -119,10 +119,9 @@ class MachObjectWriter : public MCObjectWriter {
MachSymbolData *findSymbolData(const MCSymbol &Sym);
public:
MachObjectWriter(MCMachObjectTargetWriter *MOTW, raw_ostream &_OS,
bool _IsLittleEndian)
: MCObjectWriter(_OS, _IsLittleEndian), TargetObjectWriter(MOTW) {
}
MachObjectWriter(MCMachObjectTargetWriter *MOTW, raw_ostream &OS,
bool IsLittleEndian)
: MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(MOTW) {}
/// @name Lifetime management Methods
/// @{

8
include/llvm/MC/MCObjectStreamer.h
View File

@ -49,10 +49,10 @@ class MCObjectStreamer : public MCStreamer {
void flushPendingLabels(MCFragment *F);
protected:
MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &_OS,
MCCodeEmitter *_Emitter);
MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &_OS,
MCCodeEmitter *_Emitter, MCAssembler *_Assembler);
MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &OS,
MCCodeEmitter *Emitter);
MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_ostream &OS,
MCCodeEmitter *Emitter, MCAssembler *Assembler);
~MCObjectStreamer();
public:

4
include/llvm/MC/MCObjectWriter.h
View File

@ -46,8 +46,8 @@ protected:
unsigned IsLittleEndian : 1;
protected: // Can only create subclasses.
MCObjectWriter(raw_ostream &_OS, bool _IsLittleEndian)
: OS(_OS), IsLittleEndian(_IsLittleEndian) {}
MCObjectWriter(raw_ostream &OS, bool IsLittleEndian)
: OS(OS), IsLittleEndian(IsLittleEndian) {}
public:
virtual ~MCObjectWriter();

8
include/llvm/MC/MCParser/MCAsmLexer.h
View File

@ -63,10 +63,10 @@ private:
public:
AsmToken() {}
AsmToken(TokenKind _Kind, StringRef _Str, APInt _IntVal)
: Kind(_Kind), Str(_Str), IntVal(_IntVal) {}
AsmToken(TokenKind _Kind, StringRef _Str, int64_t _IntVal = 0)
: Kind(_Kind), Str(_Str), IntVal(64, _IntVal, true) {}
AsmToken(TokenKind Kind, StringRef Str, APInt IntVal)
: Kind(Kind), Str(Str), IntVal(IntVal) {}
AsmToken(TokenKind Kind, StringRef Str, int64_t IntVal = 0)
: Kind(Kind), Str(Str), IntVal(64, IntVal, true) {}
TokenKind getKind() const { return Kind; }
bool is(TokenKind K) const { return Kind == K; }

4
include/llvm/Option/Arg.h
View File

@ -78,9 +78,7 @@ public:
const Arg &getBaseArg() const {
return BaseArg ? *BaseArg : *this;
}
void setBaseArg(const Arg *_BaseArg) {
BaseArg = _BaseArg;
}
void setBaseArg(const Arg *BaseArg) { this->BaseArg = BaseArg; }
bool getOwnsValues() const { return OwnsValues; }
void setOwnsValues(bool Value) const { OwnsValues = Value; }

8
include/llvm/Option/ArgList.h
View File

@ -52,10 +52,10 @@ public:
typedef std::forward_iterator_tag iterator_category;
typedef std::ptrdiff_t difference_type;
arg_iterator(SmallVectorImpl<Arg*>::const_iterator it,
const ArgList &_Args, OptSpecifier _Id0 = 0U,
OptSpecifier _Id1 = 0U, OptSpecifier _Id2 = 0U)
: Current(it), Args(_Args), Id0(_Id0), Id1(_Id1), Id2(_Id2) {
arg_iterator(SmallVectorImpl<Arg *>::const_iterator it, const ArgList &Args,
OptSpecifier Id0 = 0U, OptSpecifier Id1 = 0U,
OptSpecifier Id2 = 0U)
: Current(it), Args(Args), Id0(Id0), Id1(Id1), Id2(Id2) {
SkipToNextArg();
}

2
include/llvm/Option/OptSpecifier.h
View File

@ -25,7 +25,7 @@ namespace opt {
public:
OptSpecifier() : ID(0) {}
/*implicit*/ OptSpecifier(unsigned _ID) : ID(_ID) {}
/*implicit*/ OptSpecifier(unsigned ID) : ID(ID) {}
/*implicit*/ OptSpecifier(const Option *Opt);
bool isValid() const { return ID != 0; }

5
include/llvm/Option/OptTable.h
View File

@ -73,8 +73,9 @@ private:
}
protected:
OptTable(const Info *_OptionInfos, unsigned _NumOptionInfos,
bool _IgnoreCase = false);
OptTable(const Info *OptionInfos, unsigned NumOptionInfos,
bool IgnoreCase = false);
public:
~OptTable();

12
include/llvm/Support/TargetRegistry.h
View File

@ -128,7 +128,7 @@ namespace llvm {
MCContext &Ctx);
typedef MCStreamer *(*MCObjectStreamerCtorTy)(
const Target &T, StringRef TT, MCContext &Ctx, MCAsmBackend &TAB,
raw_ostream &_OS, MCCodeEmitter *_Emitter, const MCSubtargetInfo &STI,
raw_ostream &OS, MCCodeEmitter *Emitter, const MCSubtargetInfo &STI,
bool RelaxAll);
typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx,
formatted_raw_ostream &OS,
@ -416,17 +416,17 @@ namespace llvm {
/// \param TT The target triple.
/// \param Ctx The target context.
/// \param TAB The target assembler backend object. Takes ownership.
/// \param _OS The stream object.
/// \param _Emitter The target independent assembler object.Takes ownership.
/// \param OS The stream object.
/// \param Emitter The target independent assembler object.Takes ownership.
/// \param RelaxAll Relax all fixups?
MCStreamer *createMCObjectStreamer(StringRef TT, MCContext &Ctx,
MCAsmBackend &TAB, raw_ostream &_OS,
MCCodeEmitter *_Emitter,
MCAsmBackend &TAB, raw_ostream &OS,
MCCodeEmitter *Emitter,
const MCSubtargetInfo &STI,
bool RelaxAll) const {
if (!MCObjectStreamerCtorFn)
return nullptr;
return MCObjectStreamerCtorFn(*this, TT, Ctx, TAB, _OS, _Emitter, STI,
return MCObjectStreamerCtorFn(*this, TT, Ctx, TAB, OS, Emitter, STI,
RelaxAll);
}

12
lib/CodeGen/StackMapLivenessAnalysis.cpp
View File

@ -60,18 +60,18 @@ void StackMapLiveness::getAnalysisUsage(AnalysisUsage &AU) const {
}
/// Calculate the liveness information for the given machine function.
bool StackMapLiveness::runOnMachineFunction(MachineFunction &_MF) {
bool StackMapLiveness::runOnMachineFunction(MachineFunction &MF) {
if (!EnablePatchPointLiveness)
return false;
DEBUG(dbgs() << "********** COMPUTING STACKMAP LIVENESS: "
<< _MF.getName() << " **********\n");
MF = &_MF;
TRI = MF->getSubtarget().getRegisterInfo();
DEBUG(dbgs() << "********** COMPUTING STACKMAP LIVENESS: " << MF.getName()
<< " **********\n");
this->MF = &MF;
TRI = MF.getSubtarget().getRegisterInfo();
++NumStackMapFuncVisited;
// Skip this function if there are no patchpoints to process.
if (!MF->getFrameInfo()->hasPatchPoint()) {
if (!MF.getFrameInfo()->hasPatchPoint()) {
++NumStackMapFuncSkipped;
return false;
}

16
lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -464,14 +464,14 @@ static GenericValue executeFCMP_OGT(GenericValue Src1, GenericValue Src2,
return Dest; \
}
#define IMPLEMENT_VECTOR_UNORDERED(TY, X,Y, _FUNC) \
if (TY->isVectorTy()) { \
GenericValue DestMask = Dest; \
Dest = _FUNC(Src1, Src2, Ty); \
for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++) \
if (DestMask.AggregateVal[_i].IntVal == true) \
Dest.AggregateVal[_i].IntVal = APInt(1,true); \
return Dest; \
#define IMPLEMENT_VECTOR_UNORDERED(TY, X, Y, FUNC) \
if (TY->isVectorTy()) { \
GenericValue DestMask = Dest; \
Dest = FUNC(Src1, Src2, Ty); \
for (size_t _i = 0; _i < Src1.AggregateVal.size(); _i++) \
if (DestMask.AggregateVal[_i].IntVal == true) \
Dest.AggregateVal[_i].IntVal = APInt(1, true); \
return Dest; \
}
static GenericValue executeFCMP_UEQ(GenericValue Src1, GenericValue Src2,

4
lib/MC/ELFObjectWriter.cpp
View File

@ -185,9 +185,9 @@ class ELFObjectWriter : public MCObjectWriter {
}
public:
ELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_ostream &_OS,
ELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_ostream &OS,
bool IsLittleEndian)
: MCObjectWriter(_OS, IsLittleEndian), FWriter(IsLittleEndian),
: MCObjectWriter(OS, IsLittleEndian), FWriter(IsLittleEndian),
TargetObjectWriter(MOTW), NeedsGOT(false) {}
virtual ~ELFObjectWriter();

26
lib/MC/MCAssembler.cpp
View File

@ -277,9 +277,8 @@ MCFragment::MCFragment() : Kind(FragmentType(~0)) {
MCFragment::~MCFragment() {
}
MCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent)
: Kind(_Kind), Parent(_Parent), Atom(nullptr), Offset(~UINT64_C(0))
{
MCFragment::MCFragment(FragmentType Kind, MCSectionData *Parent)
: Kind(Kind), Parent(Parent), Atom(nullptr), Offset(~UINT64_C(0)) {
if (Parent)
Parent->getFragmentList().push_back(this);
}
@ -298,15 +297,10 @@ MCEncodedFragmentWithFixups::~MCEncodedFragmentWithFixups() {
MCSectionData::MCSectionData() : Section(nullptr) {}
MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A)
: Section(&_Section),
Ordinal(~UINT32_C(0)),
Alignment(1),
BundleLockState(NotBundleLocked),
BundleLockNestingDepth(0),
BundleGroupBeforeFirstInst(false),
HasInstructions(false)
{
MCSectionData::MCSectionData(const MCSection &Section, MCAssembler *A)
: Section(&Section), Ordinal(~UINT32_C(0)), Alignment(1),
BundleLockState(NotBundleLocked), BundleLockNestingDepth(0),
BundleGroupBeforeFirstInst(false), HasInstructions(false) {
if (A)
A->getSectionList().push_back(this);
}
@ -364,10 +358,10 @@ void MCSectionData::setBundleLockState(BundleLockStateType NewState) {
MCSymbolData::MCSymbolData() : Symbol(nullptr) {}
MCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment,
uint64_t _Offset, MCAssembler *A)
: Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset),
SymbolSize(nullptr), CommonAlign(-1U), Flags(0), Index(0) {
MCSymbolData::MCSymbolData(const MCSymbol &Symbol, MCFragment *Fragment,
uint64_t Offset, MCAssembler *A)
: Symbol(&Symbol), Fragment(Fragment), Offset(Offset), SymbolSize(nullptr),
CommonAlign(-1U), Flags(0), Index(0) {
if (A)
A->getSymbolList().push_back(this);
}

4
lib/MC/MCObjectStreamer.cpp
View File

@ -31,8 +31,8 @@ MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
raw_ostream &OS, MCCodeEmitter *Emitter_,
MCAssembler *_Assembler)
: MCStreamer(Context), Assembler(_Assembler), CurSectionData(nullptr),
MCAssembler *Assembler)
: MCStreamer(Context), Assembler(Assembler), CurSectionData(nullptr),
EmitEHFrame(true), EmitDebugFrame(false) {}
MCObjectStreamer::~MCObjectStreamer() {

2
lib/MC/MCParser/AsmLexer.cpp
View File

@ -21,7 +21,7 @@
#include <cstdlib>
using namespace llvm;
AsmLexer::AsmLexer(const MCAsmInfo &_MAI) : MAI(_MAI) {
AsmLexer::AsmLexer(const MCAsmInfo &MAI) : MAI(MAI) {
CurPtr = nullptr;
isAtStartOfLine = true;
AllowAtInIdentifier = !StringRef(MAI.getCommentString()).startswith("@");

10
lib/MC/MCParser/AsmParser.cpp
View File

@ -486,10 +486,10 @@ extern MCAsmParserExtension *createCOFFAsmParser();
enum { DEFAULT_ADDRSPACE = 0 };
AsmParser::AsmParser(SourceMgr &_SM, MCContext &_Ctx, MCStreamer &_Out,
const MCAsmInfo &_MAI)
: Lexer(_MAI), Ctx(_Ctx), Out(_Out), MAI(_MAI), SrcMgr(_SM),
PlatformParser(nullptr), CurBuffer(_SM.getMainFileID()),
AsmParser::AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
const MCAsmInfo &MAI)
: Lexer(MAI), Ctx(Ctx), Out(Out), MAI(MAI), SrcMgr(SM),
PlatformParser(nullptr), CurBuffer(SM.getMainFileID()),
MacrosEnabledFlag(true), HadError(false), CppHashLineNumber(0),
AssemblerDialect(~0U), IsDarwin(false), ParsingInlineAsm(false) {
// Save the old handler.
@ -500,7 +500,7 @@ AsmParser::AsmParser(SourceMgr &_SM, MCContext &_Ctx, MCStreamer &_Out,
Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
// Initialize the platform / file format parser.
switch (_Ctx.getObjectFileInfo()->getObjectFileType()) {
switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
case MCObjectFileInfo::IsCOFF:
PlatformParser.reset(createCOFFAsmParser());
break;

4
lib/MC/WinCOFFStreamer.cpp
View File

@ -230,11 +230,11 @@ void MCWinCOFFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
AssignSection(Symbol, Section);
if (ByteAlignment != 1)
new MCAlignFragment(ByteAlignment, /*_Value=*/0, /*_ValueSize=*/0,
new MCAlignFragment(ByteAlignment, /*Value=*/0, /*ValueSize=*/0,
ByteAlignment, &SectionData);
MCFillFragment *Fragment =
new MCFillFragment(/*_Value=*/0, /*_ValueSize=*/0, Size, &SectionData);
new MCFillFragment(/*Value=*/0, /*ValueSize=*/0, Size, &SectionData);
SD.setFragment(Fragment);
}

23
lib/Option/Arg.cpp
View File

@ -17,22 +17,21 @@
using namespace llvm;
using namespace llvm::opt;
Arg::Arg(const Option _Opt, StringRef S, unsigned _Index, const Arg *_BaseArg)
: Opt(_Opt), BaseArg(_BaseArg), Spelling(S), Index(_Index),
Claimed(false), OwnsValues(false) {
}
Arg::Arg(const Option Opt, StringRef S, unsigned Index, const Arg *BaseArg)
: Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
OwnsValues(false) {}
Arg::Arg(const Option _Opt, StringRef S, unsigned _Index,
const char *Value0, const Arg *_BaseArg)
: Opt(_Opt), BaseArg(_BaseArg), Spelling(S), Index(_Index),
Claimed(false), OwnsValues(false) {
Arg::Arg(const Option Opt, StringRef S, unsigned Index, const char *Value0,
const Arg *BaseArg)
: Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
OwnsValues(false) {
Values.push_back(Value0);
}
Arg::Arg(const Option _Opt, StringRef S, unsigned _Index,
const char *Value0, const char *Value1, const Arg *_BaseArg)
: Opt(_Opt), BaseArg(_BaseArg), Spelling(S), Index(_Index),
Claimed(false), OwnsValues(false) {
Arg::Arg(const Option Opt, StringRef S, unsigned Index, const char *Value0,
const char *Value1, const Arg *BaseArg)
: Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
OwnsValues(false) {
Values.push_back(Value0);
Values.push_back(Value1);
}

5
lib/Option/ArgList.cpp
View File

@ -340,9 +340,8 @@ const char *InputArgList::MakeArgString(StringRef Str) const {
//
DerivedArgList::DerivedArgList(const InputArgList &_BaseArgs)
: BaseArgs(_BaseArgs) {
}
DerivedArgList::DerivedArgList(const InputArgList &BaseArgs)
: BaseArgs(BaseArgs) {}
DerivedArgList::~DerivedArgList() {}

14
lib/Option/OptTable.cpp
View File

@ -84,15 +84,11 @@ static inline bool operator<(const OptTable::Info &I, const char *Name) {
OptSpecifier::OptSpecifier(const Option *Opt) : ID(Opt->getID()) {}
OptTable::OptTable(const Info *_OptionInfos, unsigned _NumOptionInfos,
bool _IgnoreCase)
: OptionInfos(_OptionInfos),
NumOptionInfos(_NumOptionInfos),
IgnoreCase(_IgnoreCase),
TheInputOptionID(0),
TheUnknownOptionID(0),
FirstSearchableIndex(0)
{
OptTable::OptTable(const Info *OptionInfos, unsigned NumOptionInfos,
bool IgnoreCase)
: OptionInfos(OptionInfos), NumOptionInfos(NumOptionInfos),
IgnoreCase(IgnoreCase), TheInputOptionID(0), TheUnknownOptionID(0),
FirstSearchableIndex(0) {
// Explicitly zero initialize the error to work around a bug in array
// value-initialization on MinGW with gcc 4.3.5.

26
lib/Support/DAGDeltaAlgorithm.cpp
View File

@ -63,9 +63,6 @@ private:
DAGDeltaAlgorithm &DDA;
const changeset_ty &Changes;
const std::vector<edge_ty> &Dependencies;
std::vector<change_ty> Roots;
/// Cache of failed test results. Successful test results are never cached
@ -139,9 +136,8 @@ private:
}
public:
DAGDeltaAlgorithmImpl(DAGDeltaAlgorithm &_DDA,
const changeset_ty &_Changes,
const std::vector<edge_ty> &_Dependencies);
DAGDeltaAlgorithmImpl(DAGDeltaAlgorithm &DDA, const changeset_ty &Changes,
const std::vector<edge_ty> &Dependencies);
changeset_ty Run();
@ -174,21 +170,17 @@ protected:
}
public:
DeltaActiveSetHelper(DAGDeltaAlgorithmImpl &_DDAI,
const changeset_ty &_Required)
: DDAI(_DDAI), Required(_Required) {}
DeltaActiveSetHelper(DAGDeltaAlgorithmImpl &DDAI,
const changeset_ty &Required)
: DDAI(DDAI), Required(Required) {}
};
}
DAGDeltaAlgorithmImpl::DAGDeltaAlgorithmImpl(DAGDeltaAlgorithm &_DDA,
const changeset_ty &_Changes,
const std::vector<edge_ty>
&_Dependencies)
: DDA(_DDA),
Changes(_Changes),
Dependencies(_Dependencies)
{
DAGDeltaAlgorithmImpl::DAGDeltaAlgorithmImpl(
DAGDeltaAlgorithm &DDA, const changeset_ty &Changes,
const std::vector<edge_ty> &Dependencies)
: DDA(DDA) {
for (changeset_ty::const_iterator it = Changes.begin(),
ie = Changes.end(); it != ie; ++it) {
Predecessors.insert(std::make_pair(*it, std::vector<change_ty>()));

12
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
View File

@ -113,11 +113,10 @@ public:
#define GET_OPERAND_DIAGNOSTIC_TYPES
#include "AArch64GenAsmMatcher.inc"
};
AArch64AsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
const MCInstrInfo &MII,
const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(_STI) {
MCAsmParserExtension::Initialize(_Parser);
AArch64AsmParser(MCSubtargetInfo &STI, MCAsmParser &Parser,
const MCInstrInfo &MII, const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(STI) {
MCAsmParserExtension::Initialize(Parser);
MCStreamer &S = getParser().getStreamer();
if (S.getTargetStreamer() == nullptr)
new AArch64TargetStreamer(S);
@ -254,8 +253,7 @@ private:
MCContext &Ctx;
public:
AArch64Operand(KindTy K, MCContext &_Ctx)
: MCParsedAsmOperand(), Kind(K), Ctx(_Ctx) {}
AArch64Operand(KindTy K, MCContext &Ctx) : Kind(K), Ctx(Ctx) {}
AArch64Operand(const AArch64Operand &o) : MCParsedAsmOperand(), Ctx(o.Ctx) {
Kind = o.Kind;

6
lib/Target/ARM/AsmParser/ARMAsmParser.cpp
View File

@ -342,10 +342,10 @@ public:
};
ARMAsmParser(MCSubtargetInfo & _STI, MCAsmParser & _Parser,
ARMAsmParser(MCSubtargetInfo &STI, MCAsmParser &Parser,
const MCInstrInfo &MII, const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(_STI), MII(MII), UC(_Parser) {
MCAsmParserExtension::Initialize(_Parser);
: STI(STI), MII(MII), UC(Parser) {
MCAsmParserExtension::Initialize(Parser);
// Cache the MCRegisterInfo.
MRI = getContext().getRegisterInfo();

4
lib/Target/ARM/MCTargetDesc/ARMMCExpr.h
View File

@ -26,8 +26,8 @@ private:
const VariantKind Kind;
const MCExpr *Expr;
explicit ARMMCExpr(VariantKind _Kind, const MCExpr *_Expr)
: Kind(_Kind), Expr(_Expr) {}
explicit ARMMCExpr(VariantKind Kind, const MCExpr *Expr)
: Kind(Kind), Expr(Expr) {}
public:
/// @name Construction

5
lib/Target/BPF/MCTargetDesc/BPFMCTargetDesc.cpp
View File

@ -63,11 +63,10 @@ static MCCodeGenInfo *createBPFMCCodeGenInfo(StringRef TT, Reloc::Model RM,
static MCStreamer *createBPFMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &_OS,
MCCodeEmitter *_Emitter,
raw_ostream &OS, MCCodeEmitter *Emitter,
const MCSubtargetInfo &STI,
bool RelaxAll) {
return createELFStreamer(Ctx, MAB, _OS, _Emitter, RelaxAll);
return createELFStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
}
static MCInstPrinter *

7
lib/Target/Mips/MCTargetDesc/MipsAsmBackend.h
View File

@ -32,10 +32,9 @@ class MipsAsmBackend : public MCAsmBackend {
bool Is64Bit; // 32 or 64 bit words
public:
MipsAsmBackend(const Target &T, Triple::OSType _OSType, bool _isLittle,
bool _is64Bit)
: MCAsmBackend(), OSType(_OSType), IsLittle(_isLittle),
Is64Bit(_is64Bit) {}
MipsAsmBackend(const Target &T, Triple::OSType OSType, bool IsLittle,
bool Is64Bit)
: MCAsmBackend(), OSType(OSType), IsLittle(IsLittle), Is64Bit(Is64Bit) {}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const override;

4
lib/Target/NVPTX/NVPTXAsmPrinter.h
View File

@ -92,8 +92,8 @@ class LLVM_LIBRARY_VISIBILITY NVPTXAsmPrinter : public AsmPrinter {
bool EmitGeneric;
public:
AggBuffer(unsigned _size, raw_ostream &_O, NVPTXAsmPrinter &_AP)
: size(_size), buffer(_size), O(_O), AP(_AP) {
AggBuffer(unsigned size, raw_ostream &O, NVPTXAsmPrinter &AP)
: size(size), buffer(size), O(O), AP(AP) {
curpos = 0;
numSymbols = 0;
EmitGeneric = AP.EmitGeneric;

4
lib/Target/NVPTX/NVPTXMCExpr.h
View File

@ -29,8 +29,8 @@ private:
const VariantKind Kind;
const APFloat Flt;
explicit NVPTXFloatMCExpr(VariantKind _Kind, APFloat _Flt)
: Kind(_Kind), Flt(_Flt) {}
explicit NVPTXFloatMCExpr(VariantKind Kind, APFloat Flt)
: Kind(Kind), Flt(Flt) {}
public:
/// @name Construction

6
lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp
View File

@ -271,9 +271,9 @@ class PPCAsmParser : public MCTargetAsmParser {
public:
PPCAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
const MCInstrInfo &_MII, const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(_STI), MII(_MII) {
PPCAsmParser(MCSubtargetInfo &STI, MCAsmParser &, const MCInstrInfo &MII,
const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(STI), MII(MII) {
// Check for 64-bit vs. 32-bit pointer mode.
Triple TheTriple(STI.getTargetTriple());
IsPPC64 = (TheTriple.getArch() == Triple::ppc64 ||

5
lib/Target/PowerPC/MCTargetDesc/PPCMCExpr.h
View File

@ -36,9 +36,8 @@ private:
int64_t EvaluateAsInt64(int64_t Value) const;
explicit PPCMCExpr(VariantKind _Kind, const MCExpr *_Expr,
bool _IsDarwin)
: Kind(_Kind), Expr(_Expr), IsDarwin(_IsDarwin) {}
explicit PPCMCExpr(VariantKind Kind, const MCExpr *Expr, bool IsDarwin)
: Kind(Kind), Expr(Expr), IsDarwin(IsDarwin) {}
public:
/// @name Construction

7
lib/Target/R600/AsmParser/AMDGPUAsmParser.cpp
View File

@ -46,10 +46,9 @@ class AMDGPUAsmParser : public MCTargetAsmParser {
/// }
public:
AMDGPUAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
const MCInstrInfo &_MII,
const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
AMDGPUAsmParser(MCSubtargetInfo &STI, MCAsmParser &Parser,
const MCInstrInfo &MII, const MCTargetOptions &Options)
: MCTargetAsmParser(), STI(STI), Parser(Parser) {
setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
}
bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;

4
lib/Target/R600/MCTargetDesc/AMDGPUMCTargetDesc.cpp
View File

@ -75,9 +75,9 @@ static MCInstPrinter *createAMDGPUMCInstPrinter(const Target &T,
static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &_OS, MCCodeEmitter *_Emitter,
raw_ostream &OS, MCCodeEmitter *Emitter,
const MCSubtargetInfo &STI, bool RelaxAll) {
return createELFStreamer(Ctx, MAB, _OS, _Emitter, false);
return createELFStreamer(Ctx, MAB, OS, Emitter, false);
}
extern "C" void LLVMInitializeR600TargetMC() {

4
lib/Target/Sparc/MCTargetDesc/SparcMCExpr.h
View File

@ -62,8 +62,8 @@ private:
const VariantKind Kind;
const MCExpr *Expr;
explicit SparcMCExpr(VariantKind _Kind, const MCExpr *_Expr)
: Kind(_Kind), Expr(_Expr) {}
explicit SparcMCExpr(VariantKind Kind, const MCExpr *Expr)
: Kind(Kind), Expr(Expr) {}
public:
/// @name Construction

8
lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
View File

@ -76,8 +76,8 @@ class X86AsmBackend : public MCAsmBackend {
bool HasNopl;
const uint64_t MaxNopLength;
public:
X86AsmBackend(const Target &T, StringRef _CPU)
: MCAsmBackend(), CPU(_CPU), MaxNopLength(_CPU == "slm" ? 7 : 15) {
X86AsmBackend(const Target &T, StringRef CPU)
: MCAsmBackend(), CPU(CPU), MaxNopLength(CPU == "slm" ? 7 : 15) {
HasNopl = CPU != "generic" && CPU != "i386" && CPU != "i486" &&
CPU != "i586" && CPU != "pentium" && CPU != "pentium-mmx" &&
CPU != "i686" && CPU != "k6" && CPU != "k6-2" && CPU != "k6-3" &&
@ -351,8 +351,8 @@ namespace {
class ELFX86AsmBackend : public X86AsmBackend {
public:
uint8_t OSABI;
ELFX86AsmBackend(const Target &T, uint8_t _OSABI, StringRef CPU)
: X86AsmBackend(T, CPU), OSABI(_OSABI) {}
ELFX86AsmBackend(const Target &T, uint8_t OSABI, StringRef CPU)
: X86AsmBackend(T, CPU), OSABI(OSABI) {}
};
class ELFX86_32AsmBackend : public ELFX86AsmBackend {

8
lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp
View File

@ -346,19 +346,19 @@ static MCCodeGenInfo *createX86MCCodeGenInfo(StringRef TT, Reloc::Model RM,
static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &_OS, MCCodeEmitter *_Emitter,
raw_ostream &OS, MCCodeEmitter *Emitter,
const MCSubtargetInfo &STI, bool RelaxAll) {
Triple TheTriple(TT);
switch (TheTriple.getObjectFormat()) {
default: llvm_unreachable("unsupported object format");
case Triple::MachO:
return createMachOStreamer(Ctx, MAB, _OS, _Emitter, RelaxAll);
return createMachOStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
case Triple::COFF:
assert(TheTriple.isOSWindows() && "only Windows COFF is supported");
return createX86WinCOFFStreamer(Ctx, MAB, _Emitter, _OS, RelaxAll);
return createX86WinCOFFStreamer(Ctx, MAB, Emitter, OS, RelaxAll);
case Triple::ELF:
return createELFStreamer(Ctx, MAB, _OS, _Emitter, RelaxAll);
return createELFStreamer(Ctx, MAB, OS, Emitter, RelaxAll);
}
}