[llvm-commits] [dragonegg] r117259 - in /dragonegg/trunk: llvm-abi-default.cpp llvm-abi.h llvm-backend.cpp llvm-convert.cpp llvm-types.cpp x86/llvm-target.cpp
Duncan Sands
baldrick at free.fr
Mon Oct 25 05:43:15 PDT 2010
Author: baldrick
Date: Mon Oct 25 07:43:15 2010
New Revision: 117259
URL: http://llvm.org/viewvc/llvm-project?rev=117259&view=rev
Log:
Avoid compiler warnings about unused parameters by not naming the
parameter rather than using the cast-to-void idiom.
Modified:
dragonegg/trunk/llvm-abi-default.cpp
dragonegg/trunk/llvm-abi.h
dragonegg/trunk/llvm-backend.cpp
dragonegg/trunk/llvm-convert.cpp
dragonegg/trunk/llvm-types.cpp
dragonegg/trunk/x86/llvm-target.cpp
Modified: dragonegg/trunk/llvm-abi-default.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-abi-default.cpp?rev=117259&r1=117258&r2=117259&view=diff
==============================================================================
--- dragonegg/trunk/llvm-abi-default.cpp (original)
+++ dragonegg/trunk/llvm-abi-default.cpp Mon Oct 25 07:43:15 2010
@@ -17,8 +17,7 @@
// doNotUseShadowReturn - Return true if the specified GCC type
// should not be returned using a pointer to struct parameter.
-bool doNotUseShadowReturn(tree type, tree fndecl, CallingConv::ID CC) {
- (void)CC; // Otherwise unused - avoid compiler warning.
+bool doNotUseShadowReturn(tree type, tree fndecl, CallingConv::ID /*CC*/) {
if (!TYPE_SIZE(type))
return false;
if (TREE_CODE(TYPE_SIZE(type)) != INTEGER_CST)
Modified: dragonegg/trunk/llvm-abi.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-abi.h?rev=117259&r1=117258&r2=117259&view=diff
==============================================================================
--- dragonegg/trunk/llvm-abi.h (original)
+++ dragonegg/trunk/llvm-abi.h Mon Oct 25 07:43:15 2010
@@ -54,84 +54,65 @@
/// HandleScalarResult - This callback is invoked if the function returns a
/// simple scalar result value, which is of type RetTy.
- virtual void HandleScalarResult(const Type *RetTy) {
- (void)RetTy; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleScalarResult(const Type * /*RetTy*/) {}
/// HandleAggregateResultAsScalar - This callback is invoked if the function
/// returns an aggregate value by bit converting it to the specified scalar
/// type and returning that. The bit conversion should start at byte Offset
/// within the struct, and ScalarTy is not necessarily big enough to cover
/// the entire struct.
- virtual void HandleAggregateResultAsScalar(const Type *ScalarTy,
- unsigned Offset = 0) {
- (void)ScalarTy; (void)Offset; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleAggregateResultAsScalar(const Type * /*ScalarTy*/,
+ unsigned /*Offset*/ = 0) {}
/// HandleAggregateResultAsAggregate - This callback is invoked if the function
/// returns an aggregate value using multiple return values.
- virtual void HandleAggregateResultAsAggregate(const Type *AggrTy) {
- (void)AggrTy; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleAggregateResultAsAggregate(const Type * /*AggrTy*/) {}
/// HandleAggregateShadowResult - This callback is invoked if the function
/// returns an aggregate value by using a "shadow" first parameter, which is
/// a pointer to the aggregate, of type PtrArgTy. If RetPtr is set to true,
/// the pointer argument itself is returned from the function.
- virtual void HandleAggregateShadowResult(const PointerType *PtrArgTy,
- bool RetPtr) {
- (void)PtrArgTy; (void)RetPtr; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleAggregateShadowResult(const PointerType * /*PtrArgTy*/,
+ bool /*RetPtr*/) {}
/// HandleScalarShadowResult - This callback is invoked if the function
/// returns a scalar value by using a "shadow" first parameter, which is a
/// pointer to the scalar, of type PtrArgTy. If RetPtr is set to true,
/// the pointer argument itself is returned from the function.
- virtual void HandleScalarShadowResult(const PointerType *PtrArgTy,
- bool RetPtr) {
- (void)PtrArgTy; (void)RetPtr; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleScalarShadowResult(const PointerType * /*PtrArgTy*/,
+ bool /*RetPtr*/) {}
/// HandleScalarArgument - This is the primary callback that specifies an
/// LLVM argument to pass. It is only used for first class types.
/// If RealSize is non Zero then it specifies number of bytes to access
/// from LLVMTy.
- virtual void HandleScalarArgument(const llvm::Type *LLVMTy, tree_node *type,
- unsigned RealSize = 0) {
- (void)LLVMTy; (void)type;
- (void)RealSize; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleScalarArgument(const llvm::Type * /*LLVMTy*/,
+ tree_node * /*type*/,
+ unsigned /*RealSize*/ = 0) {}
/// HandleByInvisibleReferenceArgument - This callback is invoked if a pointer
/// (of type PtrTy) to the argument is passed rather than the argument itself.
- virtual void HandleByInvisibleReferenceArgument(const llvm::Type *PtrTy,
- tree_node *type) {
- (void)PtrTy; (void)type; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleByInvisibleReferenceArgument(const llvm::Type * /*PtrTy*/,
+ tree_node * /*type*/) {}
/// HandleByValArgument - This callback is invoked if the aggregate function
/// argument is passed by value.
- virtual void HandleByValArgument(const llvm::Type *LLVMTy, tree_node *type) {
- (void)LLVMTy; (void)type; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleByValArgument(const llvm::Type * /*LLVMTy*/,
+ tree_node * /*type*/) {}
/// HandleFCAArgument - This callback is invoked if the aggregate function
/// argument is passed by value as a first class aggregate.
- virtual void HandleFCAArgument(const llvm::Type *LLVMTy, tree_node *type) {
- (void)LLVMTy; (void)type; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandleFCAArgument(const llvm::Type * /*LLVMTy*/,
+ tree_node * /*type*/) {}
/// EnterField - Called when we're about the enter the field of a struct
/// or union. FieldNo is the number of the element we are entering in the
/// LLVM Struct, StructTy is the LLVM type of the struct we are entering.
- virtual void EnterField(unsigned FieldNo, const llvm::Type *StructTy) {
- (void)FieldNo; (void)StructTy; // Otherwise unused - avoid compiler warning.
- }
+ virtual void EnterField(unsigned /*FieldNo*/,
+ const llvm::Type * /*StructTy*/) {}
virtual void ExitField() {}
- virtual void HandlePad(const llvm::Type *LLVMTy) {
- (void)LLVMTy; // Otherwise unused - avoid compiler warning.
- }
+ virtual void HandlePad(const llvm::Type * /*LLVMTy*/) {}
};
// LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY - A hook to allow
@@ -197,8 +178,8 @@
// getLLVMAggregateTypeForStructReturn - Return LLVM type if TY can be
// returns as multiple values, otherwise return NULL. This is the default
// target independent implementation.
-static inline const Type* getLLVMAggregateTypeForStructReturn(tree_node *type) {
- (void)type; // Otherwise unused - avoid compiler warning.
+static inline
+const Type* getLLVMAggregateTypeForStructReturn(tree_node * /*type*/) {
return NULL;
}
@@ -324,11 +305,9 @@
llvm_default_extract_multiple_return_value((Src),(Dest),(V),(B))
#endif
static inline
-void llvm_default_extract_multiple_return_value(Value *Src, Value *Dest,
- bool isVolatile,
- LLVMBuilder &Builder) {
- (void)Src; (void)Dest;
- (void)isVolatile; (void)Builder; // Otherwise unused - avoid compiler warning.
+void llvm_default_extract_multiple_return_value(Value * /*Src*/, Value * /*Dest*/,
+ bool /*isVolatile*/,
+ LLVMBuilder &/*Builder*/) {
assert (0 && "LLVM_EXTRACT_MULTIPLE_RETURN_VALUE is not implemented!");
}
Modified: dragonegg/trunk/llvm-backend.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-backend.cpp?rev=117259&r1=117258&r2=117259&view=diff
==============================================================================
--- dragonegg/trunk/llvm-backend.cpp (original)
+++ dragonegg/trunk/llvm-backend.cpp Mon Oct 25 07:43:15 2010
@@ -1556,9 +1556,7 @@
/// before processing the compilation unit.
/// NOTE: called even when only doing syntax checking, so do not initialize the
/// module etc here.
-static void llvm_start_unit(void *gcc_data, void *user_data) {
- (void)gcc_data; (void)user_data; // Otherwise unused - avoid compiler warning.
-
+static void llvm_start_unit(void * /*gcc_data*/, void * /*user_data*/) {
if (!quiet_flag)
errs() << "Starting compilation unit\n";
@@ -1872,9 +1870,7 @@
/// emit_same_body_alias - Turn a same-body alias into LLVM IR.
static void emit_same_body_alias(struct cgraph_node *alias,
- struct cgraph_node *target) {
- (void)target; // Otherwise unused - avoid compiler warning.
-
+ struct cgraph_node * /*target*/) {
if (errorcount || sorrycount)
return; // Do not process broken code.
@@ -1895,7 +1891,7 @@
/// emit_functions - Turn all functions in the compilation unit into LLVM IR.
static void emit_functions(cgraph_node_set set
#if (GCC_MINOR > 5)
- , varpool_node_set vset LLVM_ATTRIBUTE_UNUSED
+ , varpool_node_set /*vset*/
#endif
) {
if (errorcount || sorrycount)
@@ -1968,13 +1964,11 @@
};
/// emit_variables - Output GCC global variables to the LLVM IR.
-static void emit_variables(cgraph_node_set set
+static void emit_variables(cgraph_node_set /*set*/
#if (GCC_MINOR > 5)
- , varpool_node_set vset LLVM_ATTRIBUTE_UNUSED
+ , varpool_node_set /*vset*/
#endif
) {
- (void)set; // Otherwise unused - avoid compiler warning.
-
if (errorcount || sorrycount)
return; // Do not process broken code.
@@ -2104,16 +2098,13 @@
/// llvm_finish - Run shutdown code when GCC exits.
-static void llvm_finish(void *gcc_data, void *user_data) {
- (void)gcc_data; (void)user_data; // Otherwise unused - avoid compiler warning.
+static void llvm_finish(void * /*gcc_data*/, void * /*user_data*/) {
FinalizePlugin();
}
/// llvm_finish_unit - Finish the .s file. This is called by GCC once the
/// compilation unit has been completely processed.
-static void llvm_finish_unit(void *gcc_data, void *user_data) {
- (void)gcc_data; (void)user_data; // Otherwise unused - avoid compiler warning.
-
+static void llvm_finish_unit(void * /*gcc_data*/, void * /*user_data*/) {
if (errorcount || sorrycount)
return; // Do not process broken code.
Modified: dragonegg/trunk/llvm-convert.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-convert.cpp?rev=117259&r1=117258&r2=117259&view=diff
==============================================================================
--- dragonegg/trunk/llvm-convert.cpp (original)
+++ dragonegg/trunk/llvm-convert.cpp Mon Oct 25 07:43:15 2010
@@ -381,8 +381,7 @@
/// getCallingConv - This provides the desired CallingConv for the function.
CallingConv::ID& getCallingConv(void) { return CallingConv; }
- void HandlePad(const llvm::Type *LLVMTy) {
- (void)LLVMTy; // Otherwise unused - avoid compiler warning.
+ void HandlePad(const llvm::Type * /*LLVMTy*/) {
++AI;
}
@@ -401,8 +400,8 @@
LocStack.clear();
}
- void HandleAggregateShadowResult(const PointerType *PtrArgTy, bool RetPtr) {
- (void)PtrArgTy; (void)RetPtr; // Otherwise unused - avoid compiler warning
+ void HandleAggregateShadowResult(const PointerType * /*PtrArgTy*/,
+ bool /*RetPtr*/) {
// If the function returns a structure by value, we transform the function
// to take a pointer to the result as the first argument of the function
// instead.
@@ -436,8 +435,8 @@
++AI;
}
- void HandleScalarShadowResult(const PointerType *PtrArgTy, bool RetPtr) {
- (void)PtrArgTy; (void)RetPtr; // Otherwise unused - avoid compiler warning
+ void HandleScalarShadowResult(const PointerType * /*PtrArgTy*/,
+ bool /*RetPtr*/) {
assert(AI != Builder.GetInsertBlock()->getParent()->arg_end() &&
"No explicit return value?");
AI->setName("scalar.result");
@@ -446,9 +445,8 @@
++AI;
}
- void HandleScalarArgument(const llvm::Type *LLVMTy, tree type,
+ void HandleScalarArgument(const llvm::Type *LLVMTy, tree /*type*/,
unsigned RealSize = 0) {
- (void)type; // Otherwise unused - avoid compiler warning.
Value *ArgVal = AI;
if (ArgVal->getType() != LLVMTy) {
if (ArgVal->getType()->isPointerTy() && LLVMTy->isPointerTy()) {
@@ -476,8 +474,7 @@
++AI;
}
- void HandleByValArgument(const llvm::Type *LLVMTy, tree type) {
- (void)LLVMTy; (void)type; // Otherwise unused - avoid compiler warning.
+ void HandleByValArgument(const llvm::Type * /*LLVMTy*/, tree type) {
if (LLVM_BYVAL_ALIGNMENT_TOO_SMALL(type)) {
// Incoming object on stack is insufficiently aligned for the type.
// Make a correctly aligned copy.
@@ -508,8 +505,7 @@
++AI;
}
- void HandleFCAArgument(const llvm::Type *LLVMTy, tree type) {
- (void)LLVMTy; (void)type; // Otherwise unused - avoid compiler warning.
+ void HandleFCAArgument(const llvm::Type * /*LLVMTy*/, tree /*type*/) {
// Store the FCA argument into alloca.
assert(!LocStack.empty());
Value *Loc = LocStack.back();
@@ -518,9 +514,8 @@
++AI;
}
- void HandleAggregateResultAsScalar(const Type *ScalarTy,
+ void HandleAggregateResultAsScalar(const Type * /*ScalarTy*/,
unsigned Offset = 0) {
- (void)ScalarTy; // Otherwise unused - avoid compiler warning.
this->Offset = Offset;
}
@@ -545,8 +540,7 @@
// passed in memory byval.
static bool isPassedByVal(tree type, const Type *Ty,
std::vector<const Type*> &ScalarArgs,
- bool isShadowRet, CallingConv::ID &CC) {
- (void)CC; // Otherwise unused - avoid compiler warning.
+ bool isShadowRet, CallingConv::ID &/*CC*/) {
if (LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(type, Ty))
return true;
@@ -2602,8 +2596,7 @@
/// HandleScalarResult - This callback is invoked if the function returns a
/// simple scalar result value.
- void HandleScalarResult(const Type *RetTy) {
- (void)RetTy; // Otherwise unused - avoid compiler warning.
+ void HandleScalarResult(const Type * /*RetTy*/) {
// There is nothing to do here if we return a scalar or void.
assert(DestLoc == 0 &&
"Call returns a scalar but caller expects aggregate!");
@@ -2612,16 +2605,14 @@
/// HandleAggregateResultAsScalar - This callback is invoked if the function
/// returns an aggregate value by bit converting it to the specified scalar
/// type and returning that.
- void HandleAggregateResultAsScalar(const Type *ScalarTy,
+ void HandleAggregateResultAsScalar(const Type * /*ScalarTy*/,
unsigned Offset = 0) {
- (void)ScalarTy; // Otherwise unused - avoid compiler warning.
this->Offset = Offset;
}
/// HandleAggregateResultAsAggregate - This callback is invoked if the
/// function returns an aggregate value using multiple return values.
- void HandleAggregateResultAsAggregate(const Type *AggrTy) {
- (void)AggrTy; // Otherwise unused - avoid compiler warning.
+ void HandleAggregateResultAsAggregate(const Type * /*AggrTy*/) {
// There is nothing to do here.
isAggrRet = true;
}
@@ -2630,8 +2621,7 @@
/// returns an aggregate value by using a "shadow" first parameter. If
/// RetPtr is set to true, the pointer argument itself is returned from the
/// function.
- void HandleAggregateShadowResult(const PointerType *PtrArgTy, bool RetPtr) {
- (void)RetPtr; // Otherwise unused - avoid compiler warning.
+ void HandleAggregateShadowResult(const PointerType *PtrArgTy, bool /*RetPtr*/) {
// We need to pass memory to write the return value into.
// FIXME: alignment and volatility are being ignored!
assert(!DestLoc || PtrArgTy == DestLoc->Ptr->getType());
@@ -2664,8 +2654,8 @@
/// returns a scalar value by using a "shadow" first parameter, which is a
/// pointer to the scalar, of type PtrArgTy. If RetPtr is set to true,
/// the pointer argument itself is returned from the function.
- void HandleScalarShadowResult(const PointerType *PtrArgTy, bool RetPtr) {
- (void)RetPtr; // Otherwise unused - avoid compiler warning.
+ void HandleScalarShadowResult(const PointerType *PtrArgTy,
+ bool /*RetPtr*/) {
assert(DestLoc == 0 &&
"Call returns a scalar but caller expects aggregate!");
// Create a buffer to hold the result. The result will be loaded out of
@@ -2705,8 +2695,7 @@
/// pointer (of type PtrTy) to the argument is passed rather than the
/// argument itself.
void HandleByInvisibleReferenceArgument(const llvm::Type *PtrTy,
- tree type) {
- (void)type; // Otherwise unused - avoid compiler warning.
+ tree /*type*/) {
Value *Loc = getAddress();
Loc = Builder.CreateBitCast(Loc, PtrTy);
CallOperands.push_back(Loc);
@@ -2715,8 +2704,7 @@
/// HandleByValArgument - This callback is invoked if the aggregate function
/// argument is passed by value. It is lowered to a parameter passed by
/// reference with an additional parameter attribute "ByVal".
- void HandleByValArgument(const llvm::Type *LLVMTy, tree type) {
- (void)type; // Otherwise unused - avoid compiler warning.
+ void HandleByValArgument(const llvm::Type *LLVMTy, tree /*type*/) {
Value *Loc = getAddress();
assert(LLVMTy->getPointerTo() == Loc->getType());
(void)LLVMTy; // Otherwise unused if asserts off - avoid compiler warning.
@@ -2725,8 +2713,7 @@
/// HandleFCAArgument - This callback is invoked if the aggregate function
/// argument is passed as a first class aggregate.
- void HandleFCAArgument(const llvm::Type *LLVMTy, tree type) {
- (void)type; // Otherwise unused - avoid compiler warning.
+ void HandleFCAArgument(const llvm::Type *LLVMTy, tree /*type*/) {
Value *Loc = getAddress();
assert(LLVMTy->getPointerTo() == Loc->getType());
(void)LLVMTy; // Otherwise unused if asserts off - avoid compiler warning.
@@ -4646,8 +4633,7 @@
return true;
}
-bool TreeToLLVM::EmitBuiltinBZero(gimple stmt, Value *&Result) {
- (void)Result; // Otherwise unused - avoid compiler warning.
+bool TreeToLLVM::EmitBuiltinBZero(gimple stmt, Value *&/*Result*/) {
if (!validate_gimple_arglist(stmt, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
return false;
@@ -4871,8 +4857,7 @@
return true;
}
-bool TreeToLLVM::EmitBuiltinEHReturn(gimple stmt, Value *&Result) {
- (void)Result; // Otherwise unused - avoid compiler warning.
+bool TreeToLLVM::EmitBuiltinEHReturn(gimple stmt, Value *&/*Result*/) {
if (!validate_gimple_arglist(stmt, INTEGER_TYPE, POINTER_TYPE, VOID_TYPE))
return false;
@@ -4894,8 +4879,7 @@
return true;
}
-bool TreeToLLVM::EmitBuiltinInitDwarfRegSizes(gimple stmt, Value *&Result) {
- (void)Result; // Otherwise unused - avoid compiler warning.
+bool TreeToLLVM::EmitBuiltinInitDwarfRegSizes(gimple stmt, Value *&/*Result*/) {
#ifdef DWARF2_UNWIND_INFO
unsigned int i;
bool wrote_return_column = false;
@@ -4961,8 +4945,7 @@
return true;
}
-bool TreeToLLVM::EmitBuiltinUnwindInit(gimple stmt, Value *&Result) {
- (void)Result; // Otherwise unused - avoid compiler warning.
+bool TreeToLLVM::EmitBuiltinUnwindInit(gimple stmt, Value *&/*Result*/) {
if (!validate_gimple_arglist(stmt, VOID_TYPE))
return false;
@@ -5083,8 +5066,7 @@
return true;
}
-bool TreeToLLVM::EmitBuiltinInitTrampoline(gimple stmt, Value *&Result) {
- (void)Result; // Otherwise unused - avoid compiler warning.
+bool TreeToLLVM::EmitBuiltinInitTrampoline(gimple stmt, Value *&/*Result*/) {
if (!validate_gimple_arglist(stmt, POINTER_TYPE, POINTER_TYPE, POINTER_TYPE,
VOID_TYPE))
return false;
Modified: dragonegg/trunk/llvm-types.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/llvm-types.cpp?rev=117259&r1=117258&r2=117259&view=diff
==============================================================================
--- dragonegg/trunk/llvm-types.cpp (original)
+++ dragonegg/trunk/llvm-types.cpp Mon Oct 25 07:43:15 2010
@@ -1027,8 +1027,7 @@
}
void HandleScalarArgument(const llvm::Type *LLVMTy, tree type,
- unsigned RealSize = 0) {
- (void)RealSize; // Otherwise unused - avoid compiler warning.
+ unsigned /*RealSize*/ = 0) {
if (KNRPromotion) {
if (type == float_type_node)
LLVMTy = ConvertType(double_type_node);
@@ -1041,8 +1040,8 @@
/// HandleByInvisibleReferenceArgument - This callback is invoked if a pointer
/// (of type PtrTy) to the argument is passed rather than the argument itself.
- void HandleByInvisibleReferenceArgument(const llvm::Type *PtrTy, tree type) {
- (void)type; // Otherwise unused - avoid compiler warning.
+ void HandleByInvisibleReferenceArgument(const llvm::Type *PtrTy,
+ tree /*type*/) {
ArgTypes.push_back(PtrTy);
}
@@ -1055,8 +1054,7 @@
/// HandleFCAArgument - This callback is invoked if the aggregate function
/// argument is a first class aggregate passed by value.
- void HandleFCAArgument(const llvm::Type *LLVMTy, tree type) {
- (void)type; // Otherwise unused - avoid compiler warning.
+ void HandleFCAArgument(const llvm::Type *LLVMTy, tree /*type*/) {
ArgTypes.push_back(LLVMTy);
}
};
@@ -1462,9 +1460,8 @@
/// includes the specified byte, remove it. Return true struct
/// layout is sized properly. Return false if unable to handle ByteOffset.
/// In this case caller should redo this struct as a packed structure.
- bool ResizeLastElementIfOverlapsWith(uint64_t ByteOffset, tree Field,
+ bool ResizeLastElementIfOverlapsWith(uint64_t ByteOffset, tree /*Field*/,
const Type *Ty) {
- (void)Field; // Otherwise unused - avoid compiler warning.
const Type *SavedTy = NULL;
if (!Elements.empty()) {
Modified: dragonegg/trunk/x86/llvm-target.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/x86/llvm-target.cpp?rev=117259&r1=117258&r2=117259&view=diff
==============================================================================
--- dragonegg/trunk/x86/llvm-target.cpp (original)
+++ dragonegg/trunk/x86/llvm-target.cpp Mon Oct 25 07:43:15 2010
@@ -88,11 +88,10 @@
*/
bool TreeToLLVM::TargetIntrinsicLower(gimple stmt,
tree fndecl,
- const MemRef *DestLoc,
+ const MemRef * /*DestLoc*/,
Value *&Result,
const Type *ResultType,
std::vector<Value*> &Ops) {
- (void)DestLoc; // Otherwise unused - avoid compiler warning.
// DECL_FUNCTION_CODE contains a value of the enumerated type ix86_builtins,
// declared in i386.c. If this type was visible to us then we could simply
// use a switch statement on DECL_FUNCTION_CODE to jump to the right code for
@@ -1326,9 +1325,8 @@
/// The original implementation of this routine is based on
/// llvm_x86_64_should_pass_aggregate_in_mixed_regs code.
void
-llvm_x86_64_get_multiple_return_reg_classes(tree TreeType, const Type *Ty,
+llvm_x86_64_get_multiple_return_reg_classes(tree TreeType, const Type * /*Ty*/,
std::vector<const Type*> &Elts) {
- (void)Ty; // Otherwise unused - avoid compiler warning.
enum x86_64_reg_class Class[MAX_CLASSES];
enum machine_mode Mode = type_natural_mode(TreeType, NULL);
HOST_WIDE_INT Bytes =
More information about the llvm-commits
mailing list