template<typename T>
inline bool
DefaultFoldingSetTrait<T>::Equals(T &X, const FoldingSetNodeID &ID,
- unsigned IDHash, FoldingSetNodeID &TempID) {
+ unsigned /*IDHash*/,
+ FoldingSetNodeID &TempID) {
FoldingSetTrait<T>::Profile(X, TempID);
return TempID == ID;
}
inline bool
DefaultContextualFoldingSetTrait<T, Ctx>::Equals(T &X,
const FoldingSetNodeID &ID,
- unsigned IDHash,
+ unsigned /*IDHash*/,
FoldingSetNodeID &TempID,
Ctx Context) {
ContextualFoldingSetTrait<T, Ctx>::Profile(X, TempID, Context);
template<typename T>
inline generic_gep_type_iterator<const T *>
- gep_type_end(Type *Op0, ArrayRef<T> A) {
+ gep_type_end(Type * /*Op0*/, ArrayRef<T> A) {
return generic_gep_type_iterator<const T *>::end(A.end());
}
} // end namespace llvm
template <typename T>
typename enable_if_c<std::numeric_limits<T>::is_integer &&
!std::numeric_limits<T>::is_signed, std::size_t>::type
-countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
+countTrailingZeros(T Val, ZeroBehavior /*ZB*/ = ZB_Width) {
if (!Val)
return std::numeric_limits<T>::digits;
if (Val & 0x1)
template <typename T>
typename enable_if_c<std::numeric_limits<T>::is_integer &&
!std::numeric_limits<T>::is_signed, std::size_t>::type
-countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
+countLeadingZeros(T Val, ZeroBehavior /*ZB*/ = ZB_Width) {
if (!Val)
return std::numeric_limits<T>::digits;
TargetRegistry::RegisterMCAsmInfo(T, &Allocator);
}
private:
- static MCAsmInfo *Allocator(const MCRegisterInfo &MRI, StringRef TT) {
+ static MCAsmInfo *Allocator(const MCRegisterInfo &/*MRI*/, StringRef TT) {
return new MCAsmInfoImpl(TT);
}
TargetRegistry::RegisterMCCodeGenInfo(T, &Allocator);
}
private:
- static MCCodeGenInfo *Allocator(StringRef TT, Reloc::Model RM,
- CodeModel::Model CM, CodeGenOpt::Level OL) {
+ static MCCodeGenInfo *Allocator(StringRef /*TT*/, Reloc::Model /*RM*/,
+ CodeModel::Model /*CM*/,
+ CodeGenOpt::Level /*OL*/) {
return new MCCodeGenInfoImpl();
}
};
TargetRegistry::RegisterMCRegInfo(T, &Allocator);
}
private:
- static MCRegisterInfo *Allocator(StringRef TT) {
+ static MCRegisterInfo *Allocator(StringRef /*TT*/) {
return new MCRegisterInfoImpl();
}
};
TargetRegistry::RegisterMCSubtargetInfo(T, &Allocator);
}
private:
- static MCSubtargetInfo *Allocator(StringRef TT, StringRef CPU,
- StringRef FS) {
+ static MCSubtargetInfo *Allocator(StringRef /*TT*/, StringRef /*CPU*/,
+ StringRef /*FS*/) {
return new MCSubtargetInfoImpl();
}
};
}
private:
- static MCCodeEmitter *Allocator(const MCInstrInfo &II,
- const MCRegisterInfo &MRI,
- const MCSubtargetInfo &STI,
- MCContext &Ctx) {
+ static MCCodeEmitter *Allocator(const MCInstrInfo &/*II*/,
+ const MCRegisterInfo &/*MRI*/,
+ const MCSubtargetInfo &/*STI*/,
+ MCContext &/*Ctx*/) {
return new MCCodeEmitterImpl();
}
};
// Return the pointer type for the given address space, defaults to
// the pointer type from the data layout.
// FIXME: The default needs to be removed once all the code is updated.
- virtual MVT getPointerTy(uint32_t AS = 0) const { return PointerTy; }
+ virtual MVT getPointerTy(uint32_t /*AS*/ = 0) const { return PointerTy; }
virtual MVT getScalarShiftAmountTy(EVT LHSTy) const;
EVT getShiftAmountTy(EVT LHSTy) const;
/// this target.
bool isSelectExpensive() const { return SelectIsExpensive; }
- virtual bool isSelectSupported(SelectSupportKind kind) const { return true; }
+ virtual bool isSelectSupported(SelectSupportKind /*kind*/) const {
+ return true;
+ }
/// shouldSplitVectorElementType - Return true if a vector of the given type
/// should be split (TypeSplitVector) instead of promoted
/// (TypePromoteInteger) during type legalization.
- virtual bool shouldSplitVectorElementType(EVT VT) const { return false; }
+ virtual bool shouldSplitVectorElementType(EVT /*VT*/) const { return false; }
/// isIntDivCheap() - Return true if integer divide is usually cheaper than
/// a sequence of several shifts, adds, and multiplies for this target.
/// replacements don't generate code that causes an alignment error (trap) on
/// the target machine.
/// @brief Determine if the target supports unaligned memory accesses.
- virtual bool allowsUnalignedMemoryAccesses(EVT, bool *Fast = 0) const {
+ virtual bool allowsUnalignedMemoryAccesses(EVT, bool * /*Fast*/ = 0) const {
return false;
}
/// targets without SSE2 f64 load / store are done with fldl / fstpl which
/// also does type conversion. Note the specified type doesn't have to be
/// legal as the hook is used before type legalization.
- virtual bool isSafeMemOpType(MVT VT) const {
- return true;
- }
+ virtual bool isSafeMemOpType(MVT /*VT*/) const { return true; }
/// usesUnderscoreSetJmp - Determine if we should use _setjmp or setjmp
/// to implement llvm.setjmp.
/// much computation as possible to be done in the address mode for that
/// operand. This hook lets targets also pass back when this should be done
/// on intrinsics which load/store.
- virtual bool GetAddrModeArguments(IntrinsicInst *I,
- SmallVectorImpl<Value*> &Ops,
- Type *&AccessTy) const {
+ virtual bool GetAddrModeArguments(IntrinsicInst * /*I*/,
+ SmallVectorImpl<Value*> &/*Ops*/,
+ Type *&/*AccessTy*/) const {
return false;
}
/// tail call.
/// This is used to determine whether it is possible
/// to codegen a libcall as tail call at legalization time.
- virtual bool isUsedByReturnOnly(SDNode *, SDValue &Chain) const {
+ virtual bool isUsedByReturnOnly(SDNode *, SDValue &/*Chain*/) const {
return false;
}
formatted_raw_ostream &,
CodeGenFileType,
bool /*DisableVerify*/ = true,
- AnalysisID StartAfter = 0,
- AnalysisID StopAfter = 0) {
+ AnalysisID /*StartAfter*/ = 0,
+ AnalysisID /*StopAfter*/ = 0) {
return true;
}