[llvm-commits] [gcc-plugin] r75332 - in /gcc-plugin/trunk: llvm-convert.cpp llvm-debug.cpp llvm-internal.h llvm-types.cpp

[Duncan Sands]

Author: baldrick
Date: Fri Jul 10 22:33:22 2009
New Revision: 75332

URL: http://llvm.org/viewvc/llvm-project?rev=75332&view=rev
Log:
BLOCK_POINTER_TYPE does not exist in mainline gcc.

Modified:
    gcc-plugin/trunk/llvm-convert.cpp
    gcc-plugin/trunk/llvm-debug.cpp
    gcc-plugin/trunk/llvm-internal.h
    gcc-plugin/trunk/llvm-types.cpp

Modified: gcc-plugin/trunk/llvm-convert.cpp
URL: http://llvm.org/viewvc/llvm-project/gcc-plugin/trunk/llvm-convert.cpp?rev=75332&r1=75331&r2=75332&view=diff

==============================================================================
--- gcc-plugin/trunk/llvm-convert.cpp (original)
+++ gcc-plugin/trunk/llvm-convert.cpp Fri Jul 10 22:33:22 2009
@@ -2300,8 +2300,7 @@
 
   assert(TREE_TYPE (TREE_OPERAND (exp, 0)) &&
          (TREE_CODE(TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE ||
-          TREE_CODE(TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE ||
-          TREE_CODE(TREE_TYPE (TREE_OPERAND (exp, 0))) == BLOCK_POINTER_TYPE)
+          TREE_CODE(TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
          && "Not calling a function pointer?");
   tree function_type = TREE_TYPE(TREE_TYPE (TREE_OPERAND (exp, 0)));
   unsigned CallingConv;
@@ -6309,8 +6308,7 @@
 
   assert((TREE_CODE (ArrayTreeType) == ARRAY_TYPE ||
           TREE_CODE (ArrayTreeType) == POINTER_TYPE ||
-          TREE_CODE (ArrayTreeType) == REFERENCE_TYPE ||
-          TREE_CODE (ArrayTreeType) == BLOCK_POINTER_TYPE) &&
+          TREE_CODE (ArrayTreeType) == REFERENCE_TYPE) &&
          "Unknown ARRAY_REF!");
 
   // As an LLVM extension, we allow ARRAY_REF with a pointer as the first
@@ -7850,8 +7848,7 @@
   tree IndexType = TREE_TYPE(Index);
   assert((TREE_CODE(ArrayType) == ARRAY_TYPE ||
           TREE_CODE(ArrayType) == POINTER_TYPE ||
-          TREE_CODE(ArrayType) == REFERENCE_TYPE ||
-          TREE_CODE(ArrayType) == BLOCK_POINTER_TYPE) &&
+          TREE_CODE(ArrayType) == REFERENCE_TYPE) &&
          "Unknown ARRAY_REF!");
 
   // Check for variable sized reference.

Modified: gcc-plugin/trunk/llvm-debug.cpp
URL: http://llvm.org/viewvc/llvm-project/gcc-plugin/trunk/llvm-debug.cpp?rev=75332&r1=75331&r2=75332&view=diff

==============================================================================
--- gcc-plugin/trunk/llvm-debug.cpp (original)
+++ gcc-plugin/trunk/llvm-debug.cpp Fri Jul 10 22:33:22 2009
@@ -439,8 +439,7 @@
   DIType FromTy = getOrCreateType(TREE_TYPE(type));
   // type* and type&
   // FIXME: Should BLOCK_POINTER_TYP have its own DW_TAG?
-  unsigned Tag = (TREE_CODE(type) == POINTER_TYPE ||
-                  TREE_CODE(type) == BLOCK_POINTER_TYPE) ?
+  unsigned Tag = (TREE_CODE(type) == POINTER_TYPE) ?
     DW_TAG_pointer_type :
     DW_TAG_reference_type;
   expanded_location Loc = GetNodeLocation(type);
@@ -794,7 +793,6 @@
     
     case POINTER_TYPE:
     case REFERENCE_TYPE:
-    case BLOCK_POINTER_TYPE:
       Ty = createPointerType(type);
       break;
     

Modified: gcc-plugin/trunk/llvm-internal.h
URL: http://llvm.org/viewvc/llvm-project/gcc-plugin/trunk/llvm-internal.h?rev=75332&r1=75331&r2=75332&view=diff

==============================================================================
--- gcc-plugin/trunk/llvm-internal.h (original)
+++ gcc-plugin/trunk/llvm-internal.h Fri Jul 10 22:33:22 2009
@@ -122,7 +122,7 @@
   bool ConvertingStruct;
   
   /// PointersToReresolve - When ConvertingStruct is true, we handling of
-  /// POINTER_TYPE, REFERENCE_TYPE, and BLOCK_POINTER_TYPE is changed to return
+  /// POINTER_TYPE and REFERENCE_TYPE is changed to return
   /// opaque*'s instead of recursively calling ConvertType.  When this happens,
   /// we add the POINTER_TYPE to this list.
   ///

Modified: gcc-plugin/trunk/llvm-types.cpp
URL: http://llvm.org/viewvc/llvm-project/gcc-plugin/trunk/llvm-types.cpp?rev=75332&r1=75331&r2=75332&view=diff

==============================================================================
--- gcc-plugin/trunk/llvm-types.cpp (original)
+++ gcc-plugin/trunk/llvm-types.cpp Fri Jul 10 22:33:22 2009
@@ -303,8 +303,7 @@
 bool isSequentialCompatible(tree_node *type) {
   assert((TREE_CODE(type) == ARRAY_TYPE ||
           TREE_CODE(type) == POINTER_TYPE ||
-          TREE_CODE(type) == REFERENCE_TYPE ||
-          TREE_CODE(type) == BLOCK_POINTER_TYPE) && "not a sequential type!");
+          TREE_CODE(type) == REFERENCE_TYPE) && "not a sequential type!");
   // This relies on gcc types with constant size mapping to LLVM types with the
   // same size.  It is possible for the component type not to have a size:
   // struct foo;  extern foo bar[];
@@ -578,7 +577,6 @@
   case VECTOR_TYPE:
   case POINTER_TYPE:
   case REFERENCE_TYPE:
-  case BLOCK_POINTER_TYPE:
   case OFFSET_TYPE:
     // These types have no holes.
     return true;
@@ -764,7 +762,6 @@
     
   case POINTER_TYPE:
   case REFERENCE_TYPE:
-  case BLOCK_POINTER_TYPE:
     if (const PointerType *Ty = cast_or_null<PointerType>(GET_TYPE_LLVM(type))){
       // We already converted this type.  If this isn't a case where we have to
       // reparse it, just return it.
@@ -1235,8 +1232,7 @@
     // types.
     tree RestrictArgTy = (DeclArgs) ? TREE_TYPE(DeclArgs) : ArgTy;
     if (TREE_CODE(RestrictArgTy) == POINTER_TYPE ||
-        TREE_CODE(RestrictArgTy) == REFERENCE_TYPE ||
-        TREE_CODE(RestrictArgTy) == BLOCK_POINTER_TYPE) {
+        TREE_CODE(RestrictArgTy) == REFERENCE_TYPE) {
       if (TYPE_RESTRICT(RestrictArgTy))
         PAttributes |= Attribute::NoAlias;
     }