[llvm-commits] [dragonegg] r168544 - in /dragonegg/branches/release_32/src: ConstantConversion.cpp Convert.cpp TypeConversion.cpp
Duncan Sands
baldrick at free.fr
Sat Nov 24 08:00:45 PST 2012
Author: baldrick
Date: Sat Nov 24 10:00:45 2012
New Revision: 168544
URL: http://llvm.org/viewvc/llvm-project?rev=168544&view=rev
Log:
Revert most of revision 166675, which turned GCC vectors of pointers into LLVM
vectors of pointers. Unfortunately LLVM vectors of pointers don't work well
enough in LLVM 3.2 for this to be a good idea.
Modified:
dragonegg/branches/release_32/src/ConstantConversion.cpp
dragonegg/branches/release_32/src/Convert.cpp
dragonegg/branches/release_32/src/TypeConversion.cpp
Modified: dragonegg/branches/release_32/src/ConstantConversion.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/branches/release_32/src/ConstantConversion.cpp?rev=168544&r1=168543&r2=168544&view=diff
==============================================================================
--- dragonegg/branches/release_32/src/ConstantConversion.cpp (original)
+++ dragonegg/branches/release_32/src/ConstantConversion.cpp Sat Nov 24 10:00:45 2012
@@ -559,9 +559,17 @@
unsigned NumElts = TYPE_VECTOR_SUBPARTS(type);
unsigned Stride = GET_MODE_BITSIZE(TYPE_MODE(elt_type));
SmallVector<Constant*, 16> Vals(NumElts);
- for (unsigned i = 0; i != NumElts; ++i)
+ for (unsigned i = 0; i != NumElts; ++i) {
Vals[i] = ExtractRegisterFromConstantImpl(C, elt_type,
StartingBit+i*Stride, Folder);
+ // LLVM does not support vectors of pointers, so turn any pointers into
+ // integers.
+ if (isa<PointerType>(Vals[i]->getType())) {
+ Type *IntPtrTy =
+ getDataLayout().getIntPtrType(Vals[i]->getType());
+ Vals[i] = Folder.CreatePtrToInt(Vals[i], IntPtrTy);
+ }
+ }
return ConstantVector::get(Vals);
}
@@ -974,8 +982,15 @@
// Make the IR more pleasant by returning as a vector if the GCC type was a
// vector. However this is only correct if the initial values had the same
// type as the vector element type, rather than some random other type.
- if (isa<VECTOR_TYPE>(init_type) && ActualEltTy == EltTy)
+ if (isa<VECTOR_TYPE>(init_type) && ActualEltTy == EltTy) {
+ // If this is a vector of pointers, convert it to a vector of integers.
+ if (isa<PointerType>(EltTy)) {
+ Type *IntPtrTy = getDataLayout().getIntPtrType(EltTy);
+ for (unsigned i = 0, e = Elts.size(); i != e; ++i)
+ Elts[i] = Folder.CreatePtrToInt(Elts[i], IntPtrTy);
+ }
return ConstantVector::get(Elts);
+ }
return ConstantArray::get(ArrayType::get(ActualEltTy, Elts.size()), Elts);
}
Modified: dragonegg/branches/release_32/src/Convert.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/branches/release_32/src/Convert.cpp?rev=168544&r1=168543&r2=168544&view=diff
==============================================================================
--- dragonegg/branches/release_32/src/Convert.cpp (original)
+++ dragonegg/branches/release_32/src/Convert.cpp Sat Nov 24 10:00:45 2012
@@ -459,10 +459,16 @@
}
// Otherwise, load the vector component by component.
Value *Res = UndefValue::get(RegTy);
+ bool isVectorOfPointers = isa<PointerType>(EltRegTy);
unsigned Stride = GET_MODE_SIZE(TYPE_MODE(elt_type));
+ Type *IntPtrTy = getDataLayout().getIntPtrType(EltRegTy);
for (unsigned i = 0; i != NumElts; ++i) {
Value *Idx = Builder.getInt32(i);
Value *Elt = LoadRegisterFromMemory(Loc, elt_type, AliasTag, Builder);
+ // LLVM does not support vectors of pointers, so turn any pointers into
+ // integers.
+ if (isVectorOfPointers)
+ Elt = Builder.CreatePtrToInt(Elt, IntPtrTy);
Res = Builder.CreateInsertElement(Res, Elt, Idx);
if (i + 1 != NumElts)
Loc = DisplaceLocationByUnits(Loc, Stride, Builder);
@@ -2894,6 +2900,10 @@
BuildVecOps.push_back(Builder.CreateExtractElement(Elt, Index));
}
} else {
+ // LLVM does not support vectors of pointers, so turn any pointers into
+ // integers.
+ if (isa<PointerType>(Elt->getType()))
+ Elt = Builder.CreatePtrToInt(Elt, DL.getIntPtrType(Elt->getType()));
assert(Elt->getType() == VTy->getElementType() &&
"Unexpected type for vector constructor!");
BuildVecOps.push_back(Elt);
@@ -6598,8 +6608,16 @@
// Convert the elements.
SmallVector<Constant*, 16> Elts;
- for (tree elt = TREE_VECTOR_CST_ELTS(reg); elt; elt = TREE_CHAIN(elt))
- Elts.push_back(EmitRegisterConstant(TREE_VALUE(elt)));
+ for (tree elt = TREE_VECTOR_CST_ELTS(reg); elt; elt = TREE_CHAIN(elt)) {
+ Constant *Elt = EmitRegisterConstant(TREE_VALUE(elt));
+ // LLVM does not support vectors of pointers, so turn any pointers into
+ // integers.
+ if (isa<PointerType>(Elt->getType())) {
+ Type *IntTy = getDataLayout().getIntPtrType(Elt->getType());
+ Elt = Builder.getFolder().CreatePtrToInt(Elt, IntTy);
+ }
+ Elts.push_back(Elt);
+ }
// If there weren't enough elements then set the rest of the vector to the
// default value.
Modified: dragonegg/branches/release_32/src/TypeConversion.cpp
URL: http://llvm.org/viewvc/llvm-project/dragonegg/branches/release_32/src/TypeConversion.cpp?rev=168544&r1=168543&r2=168544&view=diff
==============================================================================
--- dragonegg/branches/release_32/src/TypeConversion.cpp (original)
+++ dragonegg/branches/release_32/src/TypeConversion.cpp Sat Nov 24 10:00:45 2012
@@ -484,8 +484,15 @@
debug_tree(type);
llvm_unreachable("Unknown FP type!");
- case VECTOR_TYPE:
- return VectorType::get(getRegType(TREE_TYPE(type)), TYPE_VECTOR_SUBPARTS(type));
+ case VECTOR_TYPE: {
+ // LLVM does not support vectors of pointers, so turn any pointers into
+ // integers. <-- This isn't true since at least 3.1 as far as I know - MicahV
+ // FIXME ^-- Yes, but does it work reliably? - Duncan
+ Type *EltTy = isa<ACCESS_TYPE>(TREE_TYPE(type)) ?
+ getDataLayout().getIntPtrType(Context, TYPE_ADDR_SPACE(TREE_TYPE(type))) :
+ getRegType(TREE_TYPE(type));
+ return VectorType::get(EltTy, TYPE_VECTOR_SUBPARTS(type));
+ }
}
}
@@ -1239,11 +1246,6 @@
return STy;
}
-static Type *ConvertVectorTypeRecursive(tree type) {
- Type *EltTy = ConvertType(TREE_TYPE(type));
- return VectorType::get(EltTy, TYPE_VECTOR_SUBPARTS(type));
-}
-
/// mayRecurse - Return true if converting this type may require breaking a
/// self-referential type loop. For example, converting the struct type
/// struct S;
@@ -1276,16 +1278,15 @@
return false;
case COMPLEX_TYPE:
- // Converting this type does involve converting another type, however that
+ case VECTOR_TYPE:
+ // Converting these types does involve converting another type, however that
// conversion cannot refer back to the initial type.
+ // NOTE: GCC supports vectors of pointers, and the pointer could refer back
+ // to the vector. However as LLVM does not support vectors of pointers we
+ // don't convert the pointer type and just use an integer instead, so as far
+ // as we are concerned such vector types are not self-referential.
return false;
- case VECTOR_TYPE:
- // If this is a vector of pointers then the pointer could refer back to the
- // vector, but this can only cause recursion if the vector was not converted
- // yet.
- return isa<ACCESS_TYPE>(TREE_TYPE(type)) && getCachedType(type) == 0;
-
case ARRAY_TYPE:
case FUNCTION_TYPE:
case METHOD_TYPE:
@@ -1372,9 +1373,6 @@
case UNION_TYPE:
case QUAL_UNION_TYPE:
return RememberTypeConversion(type, ConvertRecordTypeRecursive(type));
-
- case VECTOR_TYPE:
- return RememberTypeConversion(type, ConvertVectorTypeRecursive(type));
}
}
@@ -1414,8 +1412,7 @@
}
case COMPLEX_TYPE: {
- if (Type *Ty = getCachedType(type))
- return CheckTypeConversion(type, Ty);
+ if (Type *Ty = getCachedType(type)) return Ty;
Type *Ty = ConvertTypeNonRecursive(main_type(type));
Ty = StructType::get(Ty, Ty, NULL);
return RememberTypeConversion(type, Ty);
@@ -1461,10 +1458,15 @@
getDescriptiveName(type)));
case VECTOR_TYPE: {
- if (Type *Ty = getCachedType(type))
- return CheckTypeConversion(type, Ty);
- assert(!isa<ACCESS_TYPE>(TREE_TYPE(type)) && "Type not already converted!");
- Type *Ty = ConvertTypeNonRecursive(main_type(type));
+ if (Type *Ty = getCachedType(type)) return Ty;
+ Type *Ty;
+ // LLVM does not support vectors of pointers, so turn any pointers into
+ // integers.
+ if (isa<ACCESS_TYPE>(TREE_TYPE(type)))
+ Ty = getDataLayout().getIntPtrType(Context,
+ TYPE_ADDR_SPACE(TREE_TYPE(type)));
+ else
+ Ty = ConvertTypeNonRecursive(main_type(type));
Ty = VectorType::get(Ty, TYPE_VECTOR_SUBPARTS(type));
return RememberTypeConversion(type, Ty);
}
More information about the llvm-commits
mailing list