[llvm-commits] [llvm-gcc-4.2] r71437 - in /llvm-gcc-4.2/trunk/gcc: llvm-convert.cpp llvm-internal.h
Bill Wendling
isanbard at gmail.com
Mon May 11 09:56:06 PDT 2009
Author: void
Date: Mon May 11 11:56:01 2009
New Revision: 71437
URL: http://llvm.org/viewvc/llvm-project?rev=71437&view=rev
Log:
Getting this assert during a release full-bootstrap of llvm-gcc:
Assertion failed: ((LV.isBitfield() || cast<PointerType>(LV.Ptr->getType())->getElementType() == (VOID_TYPE_P(TREE_TYPE(exp)) ? Type::Int8Ty : ConvertType(TREE_TYPE(exp)))) && "LValue of constant has wrong type!"), function EmitLV, file ../../llvm-gcc.src/gcc/llvm-convert.cpp, line 1029.
./../llvm-gcc.src/gcc/config/darwin-crt3.c: In function 'atexit':
./../llvm-gcc.src/gcc/config/darwin-crt3.c:530: internal compiler error: Abort trap
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://llvm.org/bugs/> for instructions.
make[5]: *** [crt3.o] Error 1
make[4]: *** [extra] Error 2
make[4]: *** Waiting for unfinished jobs....
make[3]: *** [stmp-multilib] Error 2
Modified:
llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp
llvm-gcc-4.2/trunk/gcc/llvm-internal.h
Modified: llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp?rev=71437&r1=71436&r2=71437&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp Mon May 11 11:56:01 2009
@@ -930,12 +930,6 @@
assert(((DestLoc && Result == 0) || DestLoc == 0) &&
"Expected a scalar or aggregate but got the wrong thing!");
- // Check that the type of the result matches that of the tree node. If the
- // result is not used then GCC sometimes sets the tree type to VOID_TYPE, so
- // don't take VOID_TYPE too seriously here.
- assert((Result == 0 || VOID_TYPE_P(TREE_TYPE(exp)) ||
- Result->getType() == ConvertType(TREE_TYPE(exp))) &&
- "Value has wrong type!");
return Result;
}
@@ -943,8 +937,6 @@
/// the address of the result.
LValue TreeToLLVM::EmitLV(tree exp) {
// Needs to be in sync with EmitVIEW_CONVERT_EXPR.
- LValue LV(0, 0);
-
switch (TREE_CODE(exp)) {
default:
std::cerr << "Unhandled lvalue expression!\n";
@@ -955,80 +947,44 @@
case VAR_DECL:
case FUNCTION_DECL:
case CONST_DECL:
- case RESULT_DECL:
- LV = EmitLV_DECL(exp);
- break;
+ case RESULT_DECL: return EmitLV_DECL(exp);
case ARRAY_RANGE_REF:
- case ARRAY_REF:
- LV = EmitLV_ARRAY_REF(exp);
- break;
- case COMPONENT_REF:
- LV = EmitLV_COMPONENT_REF(exp);
- break;
- case BIT_FIELD_REF:
- LV = EmitLV_BIT_FIELD_REF(exp);
- break;
- case REALPART_EXPR:
- LV = EmitLV_XXXXPART_EXPR(exp, 0);
- break;
- case IMAGPART_EXPR:
- LV = EmitLV_XXXXPART_EXPR(exp, 1);
- break;
+ case ARRAY_REF: return EmitLV_ARRAY_REF(exp);
+ case COMPONENT_REF: return EmitLV_COMPONENT_REF(exp);
+ case BIT_FIELD_REF: return EmitLV_BIT_FIELD_REF(exp);
+ case REALPART_EXPR: return EmitLV_XXXXPART_EXPR(exp, 0);
+ case IMAGPART_EXPR: return EmitLV_XXXXPART_EXPR(exp, 1);
// Constants.
case LABEL_DECL: {
Value *Ptr = TreeConstantToLLVM::EmitLV_LABEL_DECL(exp);
- LV = LValue(Ptr, DECL_ALIGN(exp) / 8);
- break;
+ return LValue(Ptr, DECL_ALIGN(exp) / 8);
}
case COMPLEX_CST: {
Value *Ptr = TreeConstantToLLVM::EmitLV_COMPLEX_CST(exp);
- LV = LValue(Ptr, TYPE_ALIGN(TREE_TYPE(exp)) / 8);
- break;
+ return LValue(Ptr, TYPE_ALIGN(TREE_TYPE(exp)) / 8);
}
case STRING_CST: {
Value *Ptr = TreeConstantToLLVM::EmitLV_STRING_CST(exp);
- LV = LValue(Ptr, TYPE_ALIGN(TREE_TYPE(exp)) / 8);
- break;
+ return LValue(Ptr, TYPE_ALIGN(TREE_TYPE(exp)) / 8);
}
// Type Conversion.
- case VIEW_CONVERT_EXPR:
- LV = EmitLV_VIEW_CONVERT_EXPR(exp);
- break;
+ case VIEW_CONVERT_EXPR: return EmitLV_VIEW_CONVERT_EXPR(exp);
// Exception Handling.
- case EXC_PTR_EXPR:
- LV = EmitLV_EXC_PTR_EXPR(exp);
- break;
- case FILTER_EXPR:
- LV = EmitLV_FILTER_EXPR(exp);
- break;
+ case EXC_PTR_EXPR: return EmitLV_EXC_PTR_EXPR(exp);
+ case FILTER_EXPR: return EmitLV_FILTER_EXPR(exp);
// Trivial Cases.
case WITH_SIZE_EXPR:
// The address is the address of the operand.
- LV = EmitLV(TREE_OPERAND(exp, 0));
- break;
+ return EmitLV(TREE_OPERAND(exp, 0));
case INDIRECT_REF:
// The lvalue is just the address.
- LV = LValue(Emit(TREE_OPERAND(exp, 0), 0), expr_align(exp) / 8);
- // Correct for implicit type conversion: INDIRECT_REF can be applied to a
- // void*, resulting in a non-void type.
- LV.Ptr = BitCastToType(LV.Ptr, ConvertType(TREE_TYPE(exp))->getPointerTo());
- break;
+ return LValue(Emit(TREE_OPERAND(exp, 0), 0),
+ expr_align(exp) / 8);
}
-
- // Check that the type of the lvalue is indeed that of a pointer to the tree
- // node. This may not hold for bitfields because the type of a bitfield need
- // not match the type of the value being loaded out of it.
- assert((LV.isBitfield() ||
- cast<PointerType>(LV.Ptr->getType())->getElementType() ==
- (VOID_TYPE_P(TREE_TYPE(exp)) ?
- Type::Int8Ty : ConvertType(TREE_TYPE(exp)))) &&
- "LValue of constant has wrong type!");
-
- return LV;
}
//===----------------------------------------------------------------------===//
@@ -1341,8 +1297,8 @@
Emit(TYPE_SIZE_UNIT(type), 0), DestLoc.Alignment);
}
-Value *TreeToLLVM::EmitMemCpy(Value *DestPtr, Value *SrcPtr, Value *Size,
- unsigned Align) {
+void TreeToLLVM::EmitMemCpy(Value *DestPtr, Value *SrcPtr, Value *Size,
+ unsigned Align) {
const Type *SBP = PointerType::getUnqual(Type::Int8Ty);
const Type *IntPtr = TD.getIntPtrType();
Value *Ops[4] = {
@@ -1354,11 +1310,10 @@
Builder.CreateCall(Intrinsic::getDeclaration(TheModule, Intrinsic::memcpy,
&IntPtr, 1), Ops, Ops+4);
- return Ops[0];
}
-Value *TreeToLLVM::EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size,
- unsigned Align) {
+void TreeToLLVM::EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size,
+ unsigned Align) {
const Type *SBP = PointerType::getUnqual(Type::Int8Ty);
const Type *IntPtr = TD.getIntPtrType();
Value *Ops[4] = {
@@ -1370,11 +1325,10 @@
Builder.CreateCall(Intrinsic::getDeclaration(TheModule, Intrinsic::memmove,
&IntPtr, 1), Ops, Ops+4);
- return Ops[0];
}
-Value *TreeToLLVM::EmitMemSet(Value *DestPtr, Value *SrcVal, Value *Size,
- unsigned Align) {
+void TreeToLLVM::EmitMemSet(Value *DestPtr, Value *SrcVal, Value *Size,
+ unsigned Align) {
const Type *SBP = PointerType::getUnqual(Type::Int8Ty);
const Type *IntPtr = TD.getIntPtrType();
Value *Ops[4] = {
@@ -1386,7 +1340,6 @@
Builder.CreateCall(Intrinsic::getDeclaration(TheModule, Intrinsic::memset,
&IntPtr, 1), Ops, Ops+4);
- return Ops[0];
}
@@ -3172,18 +3125,22 @@
Value *TreeToLLVM::EmitBIT_NOT_EXPR(tree exp) {
Value *Op = Emit(TREE_OPERAND(exp, 0), 0);
- const Type *Ty = Op->getType();
- if (isa<PointerType>(Ty)) {
+ if (isa<PointerType>(Op->getType())) {
assert (TREE_CODE(TREE_TYPE(exp)) == INTEGER_TYPE &&
"Expected integer type here");
- Ty = ConvertType(TREE_TYPE(exp));
- Op = CastToType(Instruction::PtrToInt, Op, Ty);
- } else if (Ty->isFloatingPoint() ||
- (isa<VectorType>(Ty) &&
- cast<VectorType>(Ty)->getElementType()->isFloatingPoint())) {
- Op = BitCastToType(Op, getSuitableBitCastIntType(Ty));
+ Op = CastToType(Instruction::PtrToInt, Op, TREE_TYPE(exp));
+ }
+
+ const Type *Ty = Op->getType();
+ if (Ty->isFloatingPoint() ||
+ (isa<VectorType>(Ty) &&
+ cast<VectorType>(Ty)->getElementType()->isFloatingPoint())) {
+ Ty = getSuitableBitCastIntType(Ty);
+ if (!Ty)
+ abort();
+ Op = BitCastToType(Op, Ty);
}
- return BitCastToType(Builder.CreateNot(Op, (Op->getName()+"not").c_str()),Ty);
+ return Builder.CreateNot(Op, (Op->getName()+"not").c_str());
}
Value *TreeToLLVM::EmitTRUTH_NOT_EXPR(tree exp) {
@@ -3280,11 +3237,13 @@
(isa<VectorType>(Ty) &&
cast<VectorType>(Ty)->getElementType()->isFloatingPoint()))) {
Ty = getSuitableBitCastIntType(Ty);
+ if (!Ty)
+ abort();
LHS = BitCastToType(LHS, Ty);
RHS = BitCastToType(RHS, Ty);
}
- Value *V = Builder.CreateBinOp((Instruction::BinaryOps)Opc, LHS, RHS);
+ Value * V = Builder.CreateBinOp((Instruction::BinaryOps)Opc, LHS, RHS);
if (ResTy != Ty)
V = BitCastToType(V, ResTy);
return V;
@@ -4416,8 +4375,7 @@
Ty, 2),
C, C + 3);
if (isBool)
- Result = CastToUIntType(Builder.CreateICmpEQ(Result, C[1]),
- ConvertType(boolean_type_node));
+ Result = Builder.CreateICmpEQ(Result, C[1]);
else
Result = Builder.CreateIntToPtr(Result, ResultTy);
return Result;
@@ -4675,7 +4633,6 @@
Value *Amt = Emit(TREE_VALUE(TREE_OPERAND(exp, 1)), 0);
EmitBuiltinUnaryOp(Amt, Result, Intrinsic::cttz);
Result = Builder.CreateAdd(Result, ConstantInt::get(Result->getType(), 1));
- Result = CastToUIntType(Result, ConvertType(TREE_TYPE(exp)));
Value *Cond =
Builder.CreateICmpEQ(Amt, Constant::getNullValue(Amt->getType()));
Result = Builder.CreateSelect(Cond,
@@ -5106,7 +5063,7 @@
}
bool TreeToLLVM::EmitBuiltinUnaryOp(Value *InVal, Value *&Result,
- Intrinsic::ID Id) {
+ Intrinsic::ID Id) {
// The intrinsic might be overloaded in which case the argument is of
// varying type. Make sure that we specify the actual type for "iAny"
// by passing it as the 3rd and 4th parameters. This isn't needed for
@@ -5234,9 +5191,11 @@
return false;
}
- Result = isMemMove ?
- EmitMemMove(DstV, SrcV, Len, std::min(SrcAlign, DstAlign)) :
+ if (isMemMove)
+ EmitMemMove(DstV, SrcV, Len, std::min(SrcAlign, DstAlign));
+ else
EmitMemCpy(DstV, SrcV, Len, std::min(SrcAlign, DstAlign));
+ Result = DstV;
return true;
}
@@ -5264,7 +5223,8 @@
if (!OptimizeIntoPlainBuiltIn(exp, Len, Size))
return false;
}
- Result = EmitMemSet(DstV, Val, Len, DstAlign);
+ EmitMemSet(DstV, Val, Len, DstAlign);
+ Result = DstV;
return true;
}
@@ -6280,7 +6240,7 @@
const Type *EltTy = ConvertType(TREE_TYPE(exp));
FieldPtr = BitCastToType(FieldPtr, PointerType::getUnqual(EltTy));
}
-
+
assert(BitStart == 0 &&
"It's a bitfield reference or we didn't get to the field!");
return LValue(FieldPtr, LVAlign);
@@ -7268,8 +7228,6 @@
//===----------------------------------------------------------------------===//
Constant *TreeConstantToLLVM::EmitLV(tree exp) {
- Constant *LV;
-
switch (TREE_CODE(exp)) {
default:
debug_tree(exp);
@@ -7277,29 +7235,16 @@
abort();
case FUNCTION_DECL:
case CONST_DECL:
- case VAR_DECL:
- LV = EmitLV_Decl(exp);
- break;
- case LABEL_DECL:
- LV = EmitLV_LABEL_DECL(exp);
- break;
- case COMPLEX_CST:
- LV = EmitLV_COMPLEX_CST(exp);
- break;
- case STRING_CST:
- LV = EmitLV_STRING_CST(exp);
- break;
- case COMPONENT_REF:
- LV = EmitLV_COMPONENT_REF(exp);
- break;
+ case VAR_DECL: return EmitLV_Decl(exp);
+ case LABEL_DECL: return EmitLV_LABEL_DECL(exp);
+ case COMPLEX_CST: return EmitLV_COMPLEX_CST(exp);
+ case STRING_CST: return EmitLV_STRING_CST(exp);
+ case COMPONENT_REF: return EmitLV_COMPONENT_REF(exp);
case ARRAY_RANGE_REF:
- case ARRAY_REF:
- LV = EmitLV_ARRAY_REF(exp);
- break;
+ case ARRAY_REF: return EmitLV_ARRAY_REF(exp);
case INDIRECT_REF:
// The lvalue is just the address.
- LV = Convert(TREE_OPERAND(exp, 0));
- break;
+ return Convert(TREE_OPERAND(exp, 0));
case COMPOUND_LITERAL_EXPR: // FIXME: not gimple - defined by C front-end
/* This used to read
return EmitLV(COMPOUND_LITERAL_EXPR_DECL(exp));
@@ -7307,16 +7252,8 @@
with casts or the like. The following is equivalent with no checking
(since we know TREE_CODE(exp) is COMPOUND_LITERAL_EXPR the checking
doesn't accomplish anything anyway). */
- LV = EmitLV(DECL_EXPR_DECL (TREE_OPERAND (exp, 0)));
- break;
+ return EmitLV(DECL_EXPR_DECL (TREE_OPERAND (exp, 0)));
}
-
- assert(cast<PointerType>(LV->getType())->getElementType() ==
- (VOID_TYPE_P(TREE_TYPE(exp)) ?
- Type::Int8Ty : ConvertType(TREE_TYPE(exp))) &&
- "LValue of constant has wrong type!");
-
- return LV;
}
Constant *TreeConstantToLLVM::EmitLV_Decl(tree exp) {
@@ -7346,13 +7283,8 @@
if (tree ID = DECL_ASSEMBLER_NAME(exp))
mark_referenced(ID);
}
-
- // The type of the global value output for exp need not match that of exp.
- // For example if the global's initializer has a different type to the global
- // itself (allowed in GCC but not in LLVM) then the global is changed to have
- // the type of the initializer. Correct for this now.
- return TheFolder->CreateBitCast(Val,
- ConvertType(TREE_TYPE(exp))->getPointerTo());
+
+ return Val;
}
/// EmitLV_LABEL_DECL - Someone took the address of a label.
@@ -7453,6 +7385,18 @@
if (!integer_zerop(LowerBound))
Index = fold(build2(MINUS_EXPR, IndexType, Index, LowerBound));
ArrayAddr = EmitLV(Array);
+
+ // The GCC array expression value may not compile to an LLVM array type if
+ // (for example) the array value is an array of unions. In this case, the
+ // array literal will turn into an LLVM constant struct, which has struct
+ // type. Do a cast to the correct type just to be certain everything is
+ // kosher.
+ const PointerType *ResPTy = cast<PointerType>(ArrayAddr->getType());
+ if (!isa<llvm::ArrayType>(ResPTy->getElementType())) {
+ const Type *RealArrayTy = ConvertType(ArrayType);
+ ResPTy = PointerType::getUnqual(RealArrayTy);
+ ArrayAddr = TheFolder->CreateBitCast(ArrayAddr, ResPTy);
+ }
} else {
ArrayAddr = Convert(Array);
}
Modified: llvm-gcc-4.2/trunk/gcc/llvm-internal.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-internal.h?rev=71437&r1=71436&r2=71437&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-internal.h (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-internal.h Mon May 11 11:56:01 2009
@@ -430,11 +430,10 @@
void EmitAggregateZero(MemRef DestLoc, tree_node *GCCType);
/// EmitMemCpy/EmitMemMove/EmitMemSet - Emit an llvm.memcpy/llvm.memmove or
- /// llvm.memset call with the specified operands. Returns DestPtr bitcast
- /// to i8*.
- Value *EmitMemCpy(Value *DestPtr, Value *SrcPtr, Value *Size, unsigned Align);
- Value *EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size, unsigned Align);
- Value *EmitMemSet(Value *DestPtr, Value *SrcVal, Value *Size, unsigned Align);
+ /// llvm.memset call with the specified operands.
+ void EmitMemCpy(Value *DestPtr, Value *SrcPtr, Value *Size, unsigned Align);
+ void EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size, unsigned Align);
+ void EmitMemSet(Value *DestPtr, Value *SrcVal, Value *Size, unsigned Align);
/// EmitLandingPads - Emit EH landing pads.
void EmitLandingPads();
More information about the llvm-commits
mailing list