Changeset b067d9b for src/ResolvExpr/PtrsAssignable.cc

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/ResolvExpr/PtrsAssignable.cc (modified) (5 diffs)

src/ResolvExpr/PtrsAssignable.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 11:44:11 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:36:05 2016
-// Update Count     : 8
-//
-
+// Last Modified By : Andrew
+// Last Modified On : Mon Jun 24 15:29:00 2019
+// Update Count     : 9
+//
+
+#include "typeops.h"
+
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
@@ -22 +27 @@
 namespace ResolvExpr {
         struct PtrsAssignable : public WithShortCircuiting {
-                PtrsAssignable( Type *dest, const TypeEnvironment &env );
+                PtrsAssignable( const Type * dest, const TypeEnvironment &env );
 
                 int get_result() const { return result; }
 
-                void previsit( Type * ) { visit_children = false; }
-
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( FunctionType * functionType );
-                void postvisit( StructInstType * inst );
-                void postvisit( UnionInstType * inst );
-                void postvisit( EnumInstType * inst );
-                void postvisit( TraitInstType * inst );
-                void postvisit( TypeInstType * inst );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
+                void previsit( const Type * ) { visit_children = false; }
+
+                void postvisit( const VoidType * voidType );
+                void postvisit( const BasicType * basicType );
+                void postvisit( const PointerType * pointerType );
+                void postvisit( const ArrayType * arrayType );
+                void postvisit( const FunctionType * functionType );
+                void postvisit( const StructInstType * inst );
+                void postvisit( const UnionInstType * inst );
+                void postvisit( const EnumInstType * inst );
+                void postvisit( const TraitInstType * inst );
+                void postvisit( const TypeInstType * inst );
+                void postvisit( const TupleType * tupleType );
+                void postvisit( const VarArgsType * varArgsType );
+                void postvisit( const ZeroType * zeroType );
+                void postvisit( const OneType * oneType );
           private:
-                Type *dest;
+                const Type * dest;
                 int result;
                 const TypeEnvironment &env;
         };
 
-        int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env ) {
+        int ptrsAssignable( const Type *src, const Type * dest, const TypeEnvironment &env ) {
                 // std::cerr << "assignable: " << src << " | " << dest << std::endl;
-                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
+                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
+                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
                                 return ptrsAssignable( src, eqvClass->type, env );
                         } // if
                 } // if
-                if ( dynamic_cast< VoidType* >( dest ) ) {
+                if ( dynamic_cast< const VoidType* >( dest ) ) {
                         // void * = T * for any T is unsafe
                         // xxx - this should be safe, but that currently breaks the build
@@ -66 +71 @@
         }
 
-        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
-
-        void PtrsAssignable::postvisit( VoidType * ) {
+        PtrsAssignable::PtrsAssignable( const Type * dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
+
+        void PtrsAssignable::postvisit( const VoidType * ) {
                 // T * = void * is disallowed - this is a change from C, where any
                 // void * can be assigned or passed to a non-void pointer without a cast.
         }
 
-        void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {}
-        void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {}
-        void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {}
-        void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {}
-
-        void PtrsAssignable::postvisit(  __attribute__((unused)) StructInstType *inst ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
-
-        void PtrsAssignable::postvisit( EnumInstType * ) {
-                if ( dynamic_cast< BasicType* >( dest ) ) {
+        void PtrsAssignable::postvisit( const BasicType * ) {}
+        void PtrsAssignable::postvisit( const PointerType * ) {}
+        void PtrsAssignable::postvisit( const ArrayType * ) {}
+        void PtrsAssignable::postvisit( const FunctionType * ) {}
+
+        void PtrsAssignable::postvisit( const StructInstType * ) {}
+        void PtrsAssignable::postvisit( const UnionInstType * ) {}
+
+        void PtrsAssignable::postvisit( const EnumInstType * ) {
+                if ( dynamic_cast< const BasicType* >( dest ) ) {
                         // int * = E *, etc. is safe. This isn't technically correct, as each
                         // enum has one basic type that it is compatible with, an that type can
@@ -92 +97 @@
         }
 
-        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
-        void PtrsAssignable::postvisit( TypeInstType *inst ) {
-                if ( const EqvClass *eqvClass = env.lookup( inst->get_name() ) ) {
+        void PtrsAssignable::postvisit(  const TraitInstType * ) {}
+        void PtrsAssignable::postvisit( const TypeInstType * inst ) {
+                if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
                         if ( eqvClass->type ) {
                                 // T * = S * for any S depends on the type bound to T
@@ -102 +107 @@
         }
 
-        void PtrsAssignable::postvisit(  __attribute__((unused)) TupleType *tupleType ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) ZeroType *zeroType ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) OneType *oneType ) {}
+        void PtrsAssignable::postvisit( const TupleType * ) {}
+        void PtrsAssignable::postvisit( const VarArgsType * ) {}
+        void PtrsAssignable::postvisit( const ZeroType * ) {}
+        void PtrsAssignable::postvisit( const OneType * ) {}
+
+// TODO: Get rid of the `_new` suffix when the old version is removed.
+struct PtrsAssignable_new : public ast::WithShortCircuiting {
+        const ast::Type * dst;
+        const ast::TypeEnvironment & typeEnv;
+        int result;
+
+        PtrsAssignable_new( const ast::Type * dst, const ast::TypeEnvironment & env ) :
+                dst( dst ), typeEnv( env ), result( 0 ) {}
+
+        void previsit( Type * ) { visit_children = false; }
+
+        void postvisit( const ast::EnumInstType * ) {
+                if ( dynamic_cast< const ast::BasicType * >( dst ) ) {
+                        // int * = E *, etc. is safe. This isn't technically correct, as each
+                        // enum has one basic type that it is compatible with, an that type can
+                        // differ from enum to enum. Without replicating GCC's internal logic,
+                        // there is no way to know which type this particular enum is compatible
+                        // with, so punt on this for now.
+                        result = 1;
+                }
+        }
+        void postvisit( const ast::TypeInstType * inst ) {
+                if ( const ast::EqvClass * eqv = typeEnv.lookup( inst->name ) ) {
+                        if ( eqv->bound ) {
+                                // T * = S * for any S depends on the type bound to T
+                                result = ptrsAssignable( eqv->bound, dst, typeEnv );
+                        }
+                }
+        }
+};
+
+int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
+                const ast::TypeEnvironment & env ) {
+        if ( const ast::TypeInstType * dstAsInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( dstAsInst->name ) ) {
+                        return ptrsAssignable( src, eqv->bound, env );
+                }
+        }
+        if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
+                return -1;
+        } else {
+                ast::Pass<PtrsAssignable_new> visitor( dst, env );
+                src->accept( visitor );
+                return visitor.pass.result;
+        }
+
+// see ticket #136 (this should be able to replace the visitor).
+#if 0
+        if ( const ast::TypeInstType * dstAsTypeInst =
+                        dynamic_cast< const ast::TypeInstType* >( dst ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( dstAsTypeInst->get_name() ) ) {
+                        return ptrsAssignable( src, eqv->type, env );
+                } // if
+        } // if
+        if ( dynamic_cast< VoidType* >( dst ) ) {
+                // void * = T * for any T is unsafe
+                // xxx - this should be safe, but that currently breaks the build
+                return -1;
+        } else if ( dynamic_cast< EnumInstType * >( src ) ) {
+                if ( dynamic_cast< BasicType * >( dst ) ) {
+                        // int * = E *, etc. is safe. This isn't technically correct, as each
+                        // enum has one basic type that it is compatible with, an that type can
+                        // differ from enum to enum. Without replicating GCC's internal logic,
+                        // there is no way to know which type this particular enum is compatible
+                        // with, so punt on this for now.
+                        return 1;
+                }
+        } else if ( const ast::TypeInstType * typeInstType =
+                        dynamic_cast< const ast::TypeInstType * >( src ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
+                        if ( eqv->bound ) {
+                                // T * = S * for any S depends on the type bound to T
+                                return ptrsAssignable( eqv->bound, dst, env );
+                        }
+                }
+        }
+        return 0;
+#endif
+}
 
 } // namespace ResolvExpr