6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-08 18:30:04 +00:00
Code Issues Projects Releases Wiki Activity

Remove warnings about unused parameters and shadowed variables.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51266 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2008-05-19 20:15:12 +00:00
parent 9d60ba9d28
commit 13d57320bd
18 changed files with 95 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/ADT/SmallVector.h
View File

@ -300,8 +300,8 @@ public:
bool operator==(const SmallVectorImpl &RHS) const {
if (size() != RHS.size()) return false;
for (T *This = Begin, *That = RHS.Begin, *End = Begin+size();
This != End; ++This, ++That)
for (T *This = Begin, *That = RHS.Begin, *E = Begin+size();
This != E; ++This, ++That)
if (*This != *That)
return false;
return true;

15
include/llvm/CodeGen/ScheduleDAG.h
View File

@ -59,26 +59,23 @@ namespace llvm {
/// other instruction is available, issue it first.
/// * NoopHazard: issuing this instruction would break the program. If
/// some other instruction can be issued, do so, otherwise issue a noop.
virtual HazardType getHazardType(SDNode *Node) {
virtual HazardType getHazardType(SDNode *) {
return NoHazard;
}
/// EmitInstruction - This callback is invoked when an instruction is
/// emitted, to advance the hazard state.
virtual void EmitInstruction(SDNode *Node) {
}
virtual void EmitInstruction(SDNode *) {}
/// AdvanceCycle - This callback is invoked when no instructions can be
/// issued on this cycle without a hazard. This should increment the
/// internal state of the hazard recognizer so that previously "Hazard"
/// instructions will now not be hazards.
virtual void AdvanceCycle() {
}
virtual void AdvanceCycle() {}
/// EmitNoop - This callback is invoked when a noop was added to the
/// instruction stream.
virtual void EmitNoop() {
}
virtual void EmitNoop() {}
};
/// SDep - Scheduling dependency. It keeps track of dependent nodes,
@ -236,9 +233,9 @@ namespace llvm {
/// ScheduledNode - As each node is scheduled, this method is invoked. This
/// allows the priority function to adjust the priority of node that have
/// already been emitted.
virtual void ScheduledNode(SUnit *Node) {}
virtual void ScheduledNode(SUnit *) {}
virtual void UnscheduledNode(SUnit *Node) {}
virtual void UnscheduledNode(SUnit *) {}
};
class ScheduleDAG {

4
include/llvm/CodeGen/SelectionDAG.h
View File

@ -162,8 +162,8 @@ public:
MVT::ValueType VT3) {
return getVTList(VT1, VT2, VT3).VTs;
}
const MVT::ValueType *getNodeValueTypes(std::vector<MVT::ValueType> &VTList) {
return getVTList(&VTList[0], (unsigned)VTList.size()).VTs;
const MVT::ValueType *getNodeValueTypes(std::vector<MVT::ValueType> &vtList) {
return getVTList(&vtList[0], (unsigned)vtList.size()).VTs;
}

18
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -1964,15 +1964,15 @@ protected:
*/
SDUse Ops[4];
public:
LSBaseSDNode(ISD::NodeType NodeTy, SDOperand *Operands, unsigned NumOperands,
LSBaseSDNode(ISD::NodeType NodeTy, SDOperand *Operands, unsigned numOperands,
SDVTList VTs, ISD::MemIndexedMode AM, MVT::ValueType VT,
const Value *SV, int SVO, unsigned Align, bool Vol)
: SDNode(NodeTy, VTs),
AddrMode(AM), MemoryVT(VT),
SrcValue(SV), SVOffset(SVO), Alignment(Align), IsVolatile(Vol) {
for (unsigned i = 0; i != NumOperands; ++i)
for (unsigned i = 0; i != numOperands; ++i)
Ops[i] = Operands[i];
InitOperands(Ops, NumOperands);
InitOperands(Ops, numOperands);
assert(Align != 0 && "Loads and stores should have non-zero aligment");
assert((getOffset().getOpcode() == ISD::UNDEF || isIndexed()) &&
"Only indexed loads and stores have a non-undef offset operand");
@ -2004,7 +2004,7 @@ public:
/// reference performed by this load or store.
MachineMemOperand getMemOperand() const;
static bool classof(const LSBaseSDNode *N) { return true; }
static bool classof(const LSBaseSDNode *) { return true; }
static bool classof(const SDNode *N) {
return N->getOpcode() == ISD::LOAD ||
N->getOpcode() == ISD::STORE;
@ -2134,11 +2134,11 @@ struct ilist_traits<SDNode> {
//static SDNode *createNode(const SDNode &V) { return new SDNode(V); }
void addNodeToList(SDNode *NTy) {}
void removeNodeFromList(SDNode *NTy) {}
void transferNodesFromList(iplist<SDNode, ilist_traits> &L2,
const ilist_iterator<SDNode> &X,
const ilist_iterator<SDNode> &Y) {}
void addNodeToList(SDNode *) {}
void removeNodeFromList(SDNode *) {}
void transferNodesFromList(iplist<SDNode, ilist_traits> &,
const ilist_iterator<SDNode> &,
const ilist_iterator<SDNode> &) {}
};
namespace ISD {

4
include/llvm/Constant.h
View File

@ -39,8 +39,8 @@ class Constant : public User {
void operator=(const Constant &); // Do not implement
Constant(const Constant &); // Do not implement
protected:
Constant(const Type *Ty, ValueTy vty, Use *Ops, unsigned NumOps)
: User(Ty, vty, Ops, NumOps) {}
Constant(const Type *ty, ValueTy vty, Use *Ops, unsigned NumOps)
: User(ty, vty, Ops, NumOps) {}
void destroyConstantImpl();
public:

8
include/llvm/Constants.h
View File

@ -283,8 +283,8 @@ class ConstantAggregateZero : public Constant {
void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
ConstantAggregateZero(const ConstantAggregateZero &); // DO NOT IMPLEMENT
protected:
explicit ConstantAggregateZero(const Type *Ty)
: Constant(Ty, ConstantAggregateZeroVal, 0, 0) {}
explicit ConstantAggregateZero(const Type *ty)
: Constant(ty, ConstantAggregateZeroVal, 0, 0) {}
protected:
// allocate space for exactly zero operands
void *operator new(size_t s) {
@ -553,8 +553,8 @@ class ConstantExpr : public Constant {
friend struct ConvertConstantType<ConstantExpr, Type>;
protected:
ConstantExpr(const Type *Ty, unsigned Opcode, Use *Ops, unsigned NumOps)
: Constant(Ty, ConstantExprVal, Ops, NumOps) {
ConstantExpr(const Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
: Constant(ty, ConstantExprVal, Ops, NumOps) {
// Operation type (an Instruction opcode) is stored as the SubclassData.
SubclassData = Opcode;
}

22
include/llvm/DerivedTypes.h
View File

@ -67,7 +67,7 @@ public:
void dump() const { Type::dump(); }
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const DerivedType *T) { return true; }
static inline bool classof(const DerivedType *) { return true; }
static inline bool classof(const Type *T) {
return T->isDerivedType();
}
@ -127,7 +127,7 @@ public:
bool isPowerOf2ByteWidth() const;
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const IntegerType *T) { return true; }
static inline bool classof(const IntegerType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == IntegerTyID;
}
@ -179,7 +179,7 @@ public:
virtual void typeBecameConcrete(const DerivedType *AbsTy);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FunctionType *T) { return true; }
static inline bool classof(const FunctionType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == FunctionTyID;
}
@ -200,7 +200,7 @@ public:
virtual bool indexValid(const Value *V) const = 0;
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const CompositeType *T) { return true; }
static inline bool classof(const CompositeType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == ArrayTyID ||
T->getTypeID() == StructTyID ||
@ -253,7 +253,7 @@ public:
virtual void typeBecameConcrete(const DerivedType *AbsTy);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const StructType *T) { return true; }
static inline bool classof(const StructType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == StructTyID;
}
@ -292,12 +292,12 @@ public:
/// getTypeAtIndex - Given an index value into the type, return the type of
/// the element. For sequential types, there is only one subtype...
///
virtual const Type *getTypeAtIndex(const Value *V) const {
virtual const Type *getTypeAtIndex(const Value *) const {
return ContainedTys[0];
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SequentialType *T) { return true; }
static inline bool classof(const SequentialType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == ArrayTyID ||
T->getTypeID() == PointerTyID ||
@ -328,7 +328,7 @@ public:
virtual void typeBecameConcrete(const DerivedType *AbsTy);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ArrayType *T) { return true; }
static inline bool classof(const ArrayType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == ArrayTyID;
}
@ -372,7 +372,7 @@ public:
virtual void typeBecameConcrete(const DerivedType *AbsTy);
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const VectorType *T) { return true; }
static inline bool classof(const VectorType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == VectorTyID;
}
@ -407,7 +407,7 @@ public:
virtual void typeBecameConcrete(const DerivedType *AbsTy);
// Implement support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const PointerType *T) { return true; }
static inline bool classof(const PointerType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == PointerTyID;
}
@ -428,7 +428,7 @@ public:
}
// Implement support for type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const OpaqueType *T) { return true; }
static inline bool classof(const OpaqueType *) { return true; }
static inline bool classof(const Type *T) {
return T->getTypeID() == OpaqueTyID;
}

4
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -50,12 +50,12 @@ private:
public:
std::map<const GlobalValue*, void *> &
getGlobalAddressMap(const MutexGuard &locked) {
getGlobalAddressMap(const MutexGuard &) {
return GlobalAddressMap;
}
std::map<void*, const GlobalValue*> &
getGlobalAddressReverseMap(const MutexGuard& locked) {
getGlobalAddressReverseMap(const MutexGuard &) {
return GlobalAddressReverseMap;
}
};

4
include/llvm/GlobalValue.h
View File

@ -50,9 +50,9 @@ public:
};
protected:
GlobalValue(const Type *Ty, ValueTy vty, Use *Ops, unsigned NumOps,
GlobalValue(const Type *ty, ValueTy vty, Use *Ops, unsigned NumOps,
LinkageTypes linkage, const std::string &name = "")
: Constant(Ty, vty, Ops, NumOps), Parent(0),
: Constant(ty, vty, Ops, NumOps), Parent(0),
Linkage(linkage), Visibility(DefaultVisibility), Alignment(0) {
if (!name.empty()) setName(name);
}

4
include/llvm/GlobalVariable.h
View File

@ -112,11 +112,11 @@ public:
/// leads to undefined behavior.
///
bool isConstant() const { return isConstantGlobal; }
void setConstant(bool Value) { isConstantGlobal = Value; }
void setConstant(bool Val) { isConstantGlobal = Val; }
/// If the value is "Thread Local", its value isn't shared by the threads.
bool isThreadLocal() const { return isThreadLocalSymbol; }
void setThreadLocal(bool Value) { isThreadLocalSymbol = Value; }
void setThreadLocal(bool Val) { isThreadLocalSymbol = Val; }
/// removeFromParent - This method unlinks 'this' from the containing module,
/// but does not delete it.

6
include/llvm/ModuleProvider.h
View File

@ -48,7 +48,7 @@ public:
/// it up to be materialized lazily. If the provider doesn't support this
/// capability, this method is a noop.
///
virtual void dematerializeFunction(Function *F) {}
virtual void dematerializeFunction(Function *) {}
/// materializeModule - make sure the entire Module has been completely read.
/// On error, return null and fill in the error string if specified.
@ -77,10 +77,10 @@ struct ExistingModuleProvider : public ModuleProvider {
explicit ExistingModuleProvider(Module *M) {
TheModule = M;
}
bool materializeFunction(Function *F, std::string *ErrInfo = 0) {
bool materializeFunction(Function *, std::string * = 0) {
return false;
}
Module* materializeModule(std::string *ErrInfo = 0) { return TheModule; }
Module* materializeModule(std::string * = 0) { return TheModule; }
};
} // End llvm namespace

22
include/llvm/Pass.h
View File

@ -109,10 +109,10 @@ public:
/// Each pass is responsible for assigning a pass manager to itself.
/// PMS is the stack of available pass manager.
virtual void assignPassManager(PMStack &PMS,
PassManagerType T = PMT_Unknown) {}
virtual void assignPassManager(PMStack &,
PassManagerType = PMT_Unknown) {}
/// Check if available pass managers are suitable for this pass or not.
virtual void preparePassManager(PMStack &PMS) {}
virtual void preparePassManager(PMStack &) {}
/// Return what kind of Pass Manager can manage this pass.
virtual PassManagerType getPotentialPassManagerType() const {
@ -134,7 +134,7 @@ public:
/// particular analysis result to this function, it can then use the
/// getAnalysis<AnalysisType>() function, below.
///
virtual void getAnalysisUsage(AnalysisUsage &Info) const {
virtual void getAnalysisUsage(AnalysisUsage &) const {
// By default, no analysis results are used, all are invalidated.
}
@ -250,7 +250,7 @@ public:
/// ImmutablePasses are never run.
///
bool runOnModule(Module &M) { return false; }
bool runOnModule(Module &) { return false; }
explicit ImmutablePass(intptr_t pid) : ModulePass(pid) {}
explicit ImmutablePass(const void *pid)
@ -277,7 +277,7 @@ public:
/// doInitialization - Virtual method overridden by subclasses to do
/// any necessary per-module initialization.
///
virtual bool doInitialization(Module &M) { return false; }
virtual bool doInitialization(Module &) { return false; }
/// runOnFunction - Virtual method overriden by subclasses to do the
/// per-function processing of the pass.
@ -287,7 +287,7 @@ public:
/// doFinalization - Virtual method overriden by subclasses to do any post
/// processing needed after all passes have run.
///
virtual bool doFinalization(Module &M) { return false; }
virtual bool doFinalization(Module &) { return false; }
/// runOnModule - On a module, we run this pass by initializing,
/// ronOnFunction'ing once for every function in the module, then by
@ -329,12 +329,12 @@ public:
/// doInitialization - Virtual method overridden by subclasses to do
/// any necessary per-module initialization.
///
virtual bool doInitialization(Module &M) { return false; }
virtual bool doInitialization(Module &) { return false; }
/// doInitialization - Virtual method overridden by BasicBlockPass subclasses
/// to do any necessary per-function initialization.
///
virtual bool doInitialization(Function &F) { return false; }
virtual bool doInitialization(Function &) { return false; }
/// runOnBasicBlock - Virtual method overriden by subclasses to do the
/// per-basicblock processing of the pass.
@ -344,12 +344,12 @@ public:
/// doFinalization - Virtual method overriden by BasicBlockPass subclasses to
/// do any post processing needed after all passes have run.
///
virtual bool doFinalization(Function &F) { return false; }
virtual bool doFinalization(Function &) { return false; }
/// doFinalization - Virtual method overriden by subclasses to do any post
/// processing needed after all passes have run.
///
virtual bool doFinalization(Module &M) { return false; }
virtual bool doFinalization(Module &) { return false; }
// To run this pass on a function, we simply call runOnBasicBlock once for

12
include/llvm/PassSupport.h
View File

@ -53,10 +53,10 @@ public:
/// through RegisterPass.
PassInfo(const char *name, const char *arg, intptr_t pi,
NormalCtor_t normal = 0,
bool isCFGOnly = false, bool isAnalysis = false)
bool isCFGOnly = false, bool is_analysis = false)
: PassName(name), PassArgument(arg), PassID(pi),
IsCFGOnlyPass(isCFGOnly),
IsAnalysis(isAnalysis), IsAnalysisGroup(false), NormalCtor(normal) {
IsAnalysis(is_analysis), IsAnalysisGroup(false), NormalCtor(normal) {
registerPass();
}
/// PassInfo ctor - Do not call this directly, this should only be invoked
@ -169,10 +169,10 @@ struct RegisterPass : public PassInfo {
// Register Pass using default constructor...
RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false,
bool IsAnalysis = false)
bool is_analysis = false)
: PassInfo(Name, PassArg, intptr_t(&passName::ID),
PassInfo::NormalCtor_t(callDefaultCtor<passName>),
CFGOnly, IsAnalysis) {
CFGOnly, is_analysis) {
}
};
@ -244,7 +244,7 @@ struct PassRegistrationListener {
/// Callback functions - These functions are invoked whenever a pass is loaded
/// or removed from the current executable.
///
virtual void passRegistered(const PassInfo *P) {}
virtual void passRegistered(const PassInfo *) {}
/// enumeratePasses - Iterate over the registered passes, calling the
/// passEnumerate callback on each PassInfo object.
@ -254,7 +254,7 @@ struct PassRegistrationListener {
/// passEnumerate - Callback function invoked when someone calls
/// enumeratePasses on this PassRegistrationListener object.
///
virtual void passEnumerate(const PassInfo *P) {}
virtual void passEnumerate(const PassInfo *) {}
};

14
include/llvm/Support/CommandLine.h
View File

@ -226,7 +226,7 @@ public:
//
virtual void printOptionInfo(size_t GlobalWidth) const = 0;
virtual void getExtraOptionNames(std::vector<const char*> &OptionNames) {}
virtual void getExtraOptionNames(std::vector<const char*> &) {}
// addOccurrence - Wrapper around handleOccurrence that enforces Flags
//
@ -324,10 +324,10 @@ public:
Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
// Process the varargs portion of the values...
while (const char *EnumName = va_arg(ValueArgs, const char *)) {
while (const char *enumName = va_arg(ValueArgs, const char *)) {
DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
const char *EnumDesc = va_arg(ValueArgs, const char *);
Values.push_back(std::make_pair(EnumName, // Add value to value map
Values.push_back(std::make_pair(enumName, // Add value to value map
std::make_pair(EnumVal, EnumDesc)));
}
}
@ -499,9 +499,9 @@ struct basic_parser_impl { // non-template implementation of basic_parser<t>
return ValueRequired;
}
void getExtraOptionNames(std::vector<const char*> &OptionNames) {}
void getExtraOptionNames(std::vector<const char*> &) {}
void initialize(Option &O) {}
void initialize(Option &) {}
// Return the width of the option tag for printing...
size_t getOptionWidth(const Option &O) const;
@ -651,7 +651,7 @@ template<>
class parser<std::string> : public basic_parser<std::string> {
public:
// parse - Return true on error.
bool parse(Option &O, const char *AN, const std::string &Arg,
bool parse(Option &, const char *, const std::string &Arg,
std::string &Value) {
Value = Arg;
return false;
@ -1257,7 +1257,7 @@ public:
class alias : public Option {
Option *AliasFor;
virtual bool handleOccurrence(unsigned pos, const char *ArgName,
virtual bool handleOccurrence(unsigned pos, const char */*ArgName*/,
const std::string &Arg) {
return AliasFor->handleOccurrence(pos, AliasFor->ArgStr, Arg);
}

43
include/llvm/Target/TargetMachine.h
View File

@ -99,7 +99,7 @@ public:
/// used by the LLC tool to determine which target to use when an explicit
/// -march option is not specified. If a target returns zero, it will never
/// be chosen without an explicit -march option.
static unsigned getModuleMatchQuality(const Module &M) { return 0; }
static unsigned getModuleMatchQuality(const Module &) { return 0; }
/// getJITMatchQuality - This static method should be implemented by targets
/// that provide JIT capabilities to indicate how suitable they are for
@ -195,10 +195,10 @@ public:
/// This method should return FileModel::Error if emission of this file type
/// is not supported.
///
virtual FileModel::Model addPassesToEmitFile(PassManagerBase &PM,
std::ostream &Out,
CodeGenFileType FileType,
bool Fast) {
virtual FileModel::Model addPassesToEmitFile(PassManagerBase &,
std::ostream &,
CodeGenFileType,
bool /*Fast*/) {
return FileModel::None;
}
@ -206,8 +206,8 @@ public:
/// to be split up (e.g., to add an object writer pass), this method can be
/// used to finish up adding passes to emit the file, if necessary.
///
virtual bool addPassesToEmitFileFinish(PassManagerBase &PM,
MachineCodeEmitter *MCE, bool Fast) {
virtual bool addPassesToEmitFileFinish(PassManagerBase &,
MachineCodeEmitter *, bool /*Fast*/) {
return true;
}
@ -217,8 +217,9 @@ public:
/// of functions. This method returns true if machine code emission is
/// not supported.
///
virtual bool addPassesToEmitMachineCode(PassManagerBase &PM,
MachineCodeEmitter &MCE, bool Fast) {
virtual bool addPassesToEmitMachineCode(PassManagerBase &,
MachineCodeEmitter &,
bool /*Fast*/) {
return true;
}
@ -226,8 +227,8 @@ public:
/// require having the entire module at once. This is not recommended, do not
/// use this.
virtual bool WantsWholeFile() const { return false; }
virtual bool addPassesToEmitWholeFile(PassManager &PM, std::ostream &Out,
CodeGenFileType FileType, bool Fast) {
virtual bool addPassesToEmitWholeFile(PassManager &, std::ostream &,
CodeGenFileType, bool /*Fast*/) {
return true;
}
};
@ -277,14 +278,14 @@ public:
/// addInstSelector - This method should add any "last minute" LLVM->LLVM
/// passes, then install an instruction selector pass, which converts from
/// LLVM code to machine instructions.
virtual bool addInstSelector(PassManagerBase &PM, bool Fast) {
virtual bool addInstSelector(PassManagerBase &, bool /*Fast*/) {
return true;
}
/// addPreRegAllocPasses - This method may be implemented by targets that want
/// to run passes immediately before register allocation. This should return
/// true if -print-machineinstrs should print after these passes.
virtual bool addPreRegAlloc(PassManagerBase &PM, bool Fast) {
virtual bool addPreRegAlloc(PassManagerBase &, bool /*Fast*/) {
return false;
}
@ -292,14 +293,14 @@ public:
/// want to run passes after register allocation but before prolog-epilog
/// insertion. This should return true if -print-machineinstrs should print
/// after these passes.
virtual bool addPostRegAlloc(PassManagerBase &PM, bool Fast) {
virtual bool addPostRegAlloc(PassManagerBase &, bool /*Fast*/) {
return false;
}
/// addPreEmitPass - This pass may be implemented by targets that want to run
/// passes immediately before machine code is emitted. This should return
/// true if -print-machineinstrs should print out the code after the passes.
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast) {
virtual bool addPreEmitPass(PassManagerBase &, bool /*Fast*/) {
return false;
}
@ -307,16 +308,16 @@ public:
/// addAssemblyEmitter - This pass should be overridden by the target to add
/// the asmprinter, if asm emission is supported. If this is not supported,
/// 'true' should be returned.
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
virtual bool addAssemblyEmitter(PassManagerBase &, bool /*Fast*/,
std::ostream &) {
return true;
}
/// addCodeEmitter - This pass should be overridden by the target to add a
/// code emitter, if supported. If this is not supported, 'true' should be
/// returned. If DumpAsm is true, the generated assembly is printed to cerr.
virtual bool addCodeEmitter(PassManagerBase &PM, bool Fast, bool DumpAsm,
MachineCodeEmitter &MCE) {
virtual bool addCodeEmitter(PassManagerBase &, bool /*Fast*/,
bool /*DumpAsm*/, MachineCodeEmitter &) {
return true;
}
@ -324,8 +325,8 @@ public:
/// a code emitter (without setting flags), if supported. If this is not
/// supported, 'true' should be returned. If DumpAsm is true, the generated
/// assembly is printed to cerr.
virtual bool addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,
bool DumpAsm, MachineCodeEmitter &MCE) {
virtual bool addSimpleCodeEmitter(PassManagerBase &, bool /*Fast*/,
bool /*DumpAsm*/, MachineCodeEmitter &) {
return true;
}

2
include/llvm/Type.h
View File

@ -293,7 +293,7 @@ public:
static const IntegerType *Int1Ty, *Int8Ty, *Int16Ty, *Int32Ty, *Int64Ty;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Type *T) { return true; }
static inline bool classof(const Type *) { return true; }
void addRef() const {
assert(isAbstract() && "Cannot add a reference to a non-abstract type!");

4
include/llvm/User.h
View File

@ -228,8 +228,8 @@ protected:
unsigned NumOperands;
void *operator new(size_t s, unsigned Us);
User(const Type *Ty, unsigned vty, Use *OpList, unsigned NumOps)
: Value(Ty, vty), OperandList(OpList), NumOperands(NumOps) {}
User(const Type *ty, unsigned vty, Use *OpList, unsigned NumOps)
: Value(ty, vty), OperandList(OpList), NumOperands(NumOps) {}
Use *allocHungoffUses(unsigned) const;
void dropHungoffUses(Use *U) {
if (OperandList == U) {

2
include/llvm/Value.h
View File

@ -232,7 +232,7 @@ inline std::ostream &operator<<(std::ostream &OS, const Value &V) {
return OS;
}
void Use::init(Value *V, User *user) {
void Use::init(Value *V, User *) {
Val = V;
if (V) V->addUse(*this);
}