Changeset fe63ae6 for src

Timestamp:

Apr 12, 2021, 5:16:45 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

a1b9bc3

Parents:

56c8b86 (diff), 73f4d08 (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

Location:

src

Files:

• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (8 diffs)
• SynTree/Constant.cc (modified) (1 diff)
• SynTree/Constant.h (modified) (1 diff)
• Virtual/ExpandCasts.cc (modified) (7 diffs)
• Virtual/Tables.cc (modified) (4 diffs)
• Virtual/Tables.h (modified) (3 diffs)

src/AST/Expr.cpp

@@ -260 +260 @@
 }
 
+ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & str ) {
+        const Type * charType = new BasicType( BasicType::Char );
+        // Adjust the length of the string for the terminator.
+        const Expr * strSize = from_ulong( loc, str.size() + 1 );
+        const Type * strType = new ArrayType( charType, strSize, FixedLen, StaticDim );
+        const std::string strValue = "\"" + str + "\"";
+        return new ConstantExpr( loc, strType, strValue, std::nullopt );
+}
+
 ConstantExpr * ConstantExpr::null( const CodeLocation & loc, const Type * ptrType ) {
         return new ConstantExpr{

src/AST/Expr.hpp

@@ -438 +438 @@
         long long int intValue() const;
 
-        /// generates a boolean constant of the given bool
+        /// Generates a boolean constant of the given bool.
         static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
-        /// generates an integer constant of the given int
+        /// Generates an integer constant of the given int.
         static ConstantExpr * from_int( const CodeLocation & loc, int i );
-        /// generates an integer constant of the given unsigned long int
+        /// Generates an integer constant of the given unsigned long int.
         static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
-        /// generates a null pointer value for the given type. void * if omitted.
+        /// Generates a string constant from the given string (char type, unquoted string).
+        static ConstantExpr * from_string( const CodeLocation & loc, const std::string & string );
+        /// Generates a null pointer value for the given type. void * if omitted.
         static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );
 

src/Concurrency/Keywords.cc

@@ -42 +42 @@
 
 namespace Concurrency {
+        inline static std::string getTypeIdName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::typeIdType( exception_name );
+        }
         inline static std::string getVTableName( std::string const & exception_name ) {
-                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName( exception_name );
         }
 
@@ -75 +78 @@
                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
                   context_error( context_error ), exception_name( exception_name ),
+                  typeid_name( getTypeIdName( exception_name ) ),
                   vtable_name( getVTableName( exception_name ) ),
                   needs_main( needs_main ), cast_target( cast_target ) {}
@@ -84 +88 @@
 
                 void handle( StructDecl * );
+                void addTypeId( StructDecl * );
                 void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
@@ -99 +104 @@
                 const std::string context_error;
                 const std::string exception_name;
+                const std::string typeid_name;
                 const std::string vtable_name;
                 bool needs_main;
@@ -106 +112 @@
                 FunctionDecl * dtor_decl = nullptr;
                 StructDecl * except_decl = nullptr;
+                StructDecl * typeid_decl = nullptr;
                 StructDecl * vtable_decl = nullptr;
         };
@@ -392 +399 @@
                 else if ( !except_decl && exception_name == decl->name && decl->body ) {
                         except_decl = decl;
+                }
+                else if ( !typeid_decl && typeid_name == decl->name && decl->body ) {
+                        typeid_decl = decl;
                 }
                 else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
@@ -448 +458 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
-                addVtableForward( decl );
+                if ( !exception_name.empty() ) {
+                        if( !typeid_decl ) SemanticError( decl, context_error );
+                        if( !vtable_decl ) SemanticError( decl, context_error );
+
+                        addTypeId( decl );
+                        addVtableForward( decl );
+                }
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
@@ -454 +470 @@
         }
 
+        void ConcurrentSueKeyword::addTypeId( StructDecl * decl ) {
+                assert( typeid_decl );
+                StructInstType typeid_type( Type::Const, typeid_decl );
+                typeid_type.parameters.push_back( new TypeExpr(
+                        new StructInstType( noQualifiers, decl )
+                        ) );
+                declsToAddBefore.push_back( Virtual::makeTypeIdInstance( &typeid_type ) );
+        }
+
         void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
-                if ( vtable_decl ) {
-                        std::list< Expression * > poly_args = {
-                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
-                        };
-                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
-                                vtable_decl->makeInst( poly_args ),
-                                except_decl->makeInst( poly_args )
-                        ) );
-                        declsToAddBefore.push_back( Virtual::makeVtableForward(
-                                vtable_decl->makeInst( move( poly_args ) ) ) );
-                // Its only an error if we want a vtable and don't have one.
-                } else if ( ! vtable_name.empty() ) {
-                        SemanticError( decl, context_error );
-                }
+                assert( vtable_decl );
+                std::list< Expression * > poly_args = {
+                        new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                };
+                declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                        vtable_decl->makeInst( poly_args ),
+                        except_decl->makeInst( poly_args )
+                ) );
+                declsToAddBefore.push_back( Virtual::makeVtableForward(
+                        vtable_decl->makeInst( move( poly_args ) ) ) );
         }
 

src/SynTree/Constant.cc

@@ -42 +42 @@
 }
 
+Constant Constant::from_string( const std::string & str ) {
+        Type * charType = new BasicType( noQualifiers, BasicType::Char );
+        // Adjust the length of the string for the terminator.
+        Expression * strSize = new ConstantExpr( Constant::from_ulong( str.size() + 1 ) );
+        Type * strType = new ArrayType( noQualifiers, charType, strSize, false, false );
+        const std::string strValue = "\"" + str + "\"";
+        return Constant( strType, strValue, std::nullopt );
+}
+
 Constant Constant::null( Type * ptrtype ) {
         if ( nullptr == ptrtype ) {

src/SynTree/Constant.h

@@ -47 +47 @@
         /// generates an integer constant of the given unsigned long int
         static Constant from_ulong( unsigned long i );
+        /// generates a string constant from the given string (char type, unquoted string)
+        static Constant from_string( const std::string & string );
 
         /// generates a null pointer value for the given type. void * if omitted.

src/Virtual/ExpandCasts.cc

@@ -32 +32 @@
 namespace Virtual {
 
+static bool is_prefix( const std::string & prefix, const std::string& entire ) {
+        size_t const p_size = prefix.size();
+        return (p_size < entire.size() && prefix == entire.substr(0, p_size));
+}
+
+static bool is_type_id_object( const ObjectDecl * objectDecl ) {
+        const std::string & objectName = objectDecl->name;
+        return is_prefix( "__cfatid_", objectName );
+}
+
         // Indented until the new ast code gets added.
 
@@ -66 +76 @@
         };
 
-        /* Currently virtual depends on the rather brittle name matching between
-         * a (strict/explicate) virtual type, its vtable type and the vtable
-         * instance.
-         * A stronger implementation, would probably keep track of those triads
-         * and use that information to create better error messages.
-         */
-
-        namespace {
-
-        std::string get_vtable_name( std::string const & name ) {
-                return name + "_vtable";
-        }
-
-        std::string get_vtable_inst_name( std::string const & name ) {
-                return std::string("_") + get_vtable_name( name ) + "_instance";
-        }
-
-        std::string get_vtable_name_root( std::string const & name ) {
-                return name.substr(0, name.size() - 7 );
-        }
-
-        std::string get_vtable_inst_name_root( std::string const & name ) {
-                return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
-        }
-
-        bool is_vtable_inst_name( std::string const & name ) {
-                return 17 < name.size() &&
-                        name == get_vtable_inst_name( get_vtable_inst_name_root( name ) );
-        }
-
-        } // namespace
-
         class VirtualCastCore {
-                Type * pointer_to_pvt(int level_of_indirection) {
+                CastExpr * cast_to_type_id( Expression * expr, int level_of_indirection ) {
                         Type * type = new StructInstType(
                                 Type::Qualifiers( Type::Const ), pvt_decl );
@@ -105 +83 @@
                                 type = new PointerType( noQualifiers, type );
                         }
-                        return type;
+                        return new CastExpr( expr, type );
                 }
 
@@ -141 +119 @@
 
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
-                if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
-                        if ( ObjectDecl * existing = indexer.insert( objectDecl ) ) {
-                                std::string msg = "Repeated instance of virtual table, original found at: ";
-                                msg += existing->location.filename;
-                                msg += ":" + toString( existing->location.first_line );
-                                SemanticError( objectDecl->location, msg );
-                        }
+                if ( is_type_id_object( objectDecl ) ) {
+                        // Multiple definitions should be fine because of linkonce.
+                        indexer.insert( objectDecl );
                 }
         }
@@ -170 +144 @@
         }
 
-        /// Get the virtual table type used in a virtual cast.
-        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
-                const Type * objectType;
-                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
-                        objectType = target->base;
-                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
-                        objectType = target->base;
+        /// Get the base type from a pointer or reference.
+        const Type * getBaseType( const Type * type ) {
+                if ( auto target = dynamic_cast<const PointerType *>( type ) ) {
+                        return target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( type ) ) {
+                        return target->base;
                 } else {
-                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
-                }
-                assert( objectType );
-
-                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
-                if ( nullptr == structType ) {
-                        castError( castExpr, "Virtual cast type must refer to a structure type." );
-                }
-                const StructDecl * structDecl = structType->baseStruct;
-                assert( structDecl );
-
-                const ObjectDecl * fieldDecl = nullptr;
-                if ( 0 < structDecl->members.size() ) {
-                        const Declaration * memberDecl = structDecl->members.front();
+                        return nullptr;
+                }
+        }
+
+        /* Attempt to follow the "head" field of the structure to get the...
+         * Returns nullptr on error, otherwise owner must free returned node.
+         */
+        StructInstType * followHeadPointerType(
+                        const StructInstType * oldType,
+                        const std::string& fieldName,
+                        const CodeLocation& errorLocation ) {
+
+                // First section of the function is all about trying to fill this variable in.
+                StructInstType * newType = nullptr;
+                {
+                        const StructDecl * oldDecl = oldType->baseStruct;
+                        assert( oldDecl );
+
+                        // Helper function for throwing semantic errors.
+                        auto throwError = [&fieldName, &errorLocation, &oldDecl](const std::string& message) {
+                                const std::string& context = "While following head pointer of " +
+                                        oldDecl->name + " named '" + fieldName + "': ";
+                                SemanticError( errorLocation, context + message );
+                        };
+
+                        if ( oldDecl->members.empty() ) {
+                                throwError( "Type has no fields." );
+                        }
+                        const Declaration * memberDecl = oldDecl->members.front();
                         assert( memberDecl );
-                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
-                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
-                                fieldDecl = nullptr;
-                        }
-                }
-                if ( nullptr == fieldDecl ) {
-                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
-                }
-                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
-                if ( nullptr == fieldType ) {
-                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
-                }
-                assert( fieldType->base );
-                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
-                assert( virtualStructType );
-
-                // Here is the type, but if it is polymorphic it will have lost information.
-                // (Always a clone so that it may always be deleted.)
-                StructInstType * virtualType = virtualStructType->clone();
-                if ( ! structType->parameters.empty() ) {
-                        deleteAll( virtualType->parameters );
-                        virtualType->parameters.clear();
-                        cloneAll( structType->parameters, virtualType->parameters );
-                }
-                return virtualType;
+                        const ObjectDecl * fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        assert( fieldDecl );
+                        if ( fieldName != fieldDecl->name ) {
+                                throwError( "Head field did not have expected name." );
+                        }
+
+                        const Type * fieldType = fieldDecl->type;
+                        if ( nullptr == fieldType ) {
+                                throwError( "Could not get head field." );
+                        }
+                        const PointerType * ptrType = dynamic_cast<const PointerType *>( fieldType );
+                        if ( nullptr == ptrType ) {
+                                throwError( "First field is not a pointer type." );
+                        }
+                        assert( ptrType->base );
+                        newType = dynamic_cast<StructInstType *>( ptrType->base );
+                        if ( nullptr == newType ) {
+                                throwError( "First field does not point to a structure type." );
+                        }
+                }
+
+                // Now we can look into copying it.
+                newType = newType->clone();
+                if ( ! oldType->parameters.empty() ) {
+                        deleteAll( newType->parameters );
+                        newType->parameters.clear();
+                        cloneAll( oldType->parameters, newType->parameters );
+                }
+                return newType;
+        }
+
+        /// Get the type-id type from a virtual type.
+        StructInstType * getTypeIdType( const Type * type, const CodeLocation& errorLocation ) {
+                const StructInstType * typeInst = dynamic_cast<const StructInstType *>( type );
+                if ( nullptr == typeInst ) {
+                        return nullptr;
+                }
+                StructInstType * tableInst =
+                        followHeadPointerType( typeInst, "virtual_table", errorLocation );
+                if ( nullptr == tableInst ) {
+                        return nullptr;
+                }
+                StructInstType * typeIdInst =
+                        followHeadPointerType( tableInst, "__cfavir_typeid", errorLocation );
+                delete tableInst;
+                return typeIdInst;
         }
 
@@ -228 +237 @@
                 assert( pvt_decl );
 
-                const Type * vtable_type = getVirtualTableType( castExpr );
-                ObjectDecl * table = indexer.lookup( vtable_type );
-                if ( nullptr == table ) {
-                        SemanticError( castLocation( castExpr ),
-                                "Could not find virtual table instance." );
+                const Type * base_type = getBaseType( castExpr->result );
+                if ( nullptr == base_type ) {
+                        castError( castExpr, "Virtual cast target must be a pointer or reference type." );
+                }
+                const Type * type_id_type = getTypeIdType( base_type, castLocation( castExpr ) );
+                if ( nullptr == type_id_type ) {
+                        castError( castExpr, "Ill formed virtual cast target type." );
+                }
+                ObjectDecl * type_id = indexer.lookup( type_id_type );
+                delete type_id_type;
+                if ( nullptr == type_id ) {
+                        castError( castExpr, "Virtual cast does not target a virtual type." );
                 }
 
                 Expression * result = new CastExpr(
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
-                                        new CastExpr(
-                                                new AddressExpr( new VariableExpr( table ) ),
-                                                pointer_to_pvt(1)
-                                        ),
-                                        new CastExpr(
-                                                castExpr->get_arg(),
-                                                pointer_to_pvt(2)
-                                        )
+                                cast_to_type_id( new AddressExpr( new VariableExpr( type_id ) ), 1 ),
+                                cast_to_type_id( castExpr->get_arg(), 2 ),
                         } ),
                         castExpr->get_result()->clone()
@@ -252 +262 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
-                delete vtable_type;
                 return result;
         }

src/Virtual/Tables.cc

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:11:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep  3 14:56:00 2020
-// Update Count     : 0
+// Last Modified On : Thr Apr  8 15:51:00 2021
+// Update Count     : 1
 //
 
@@ -22 +22 @@
 namespace Virtual {
 
+std::string typeIdType( std::string const & type_name ) {
+        return "__cfatid_struct_" + type_name;
+}
+
+std::string typeIdName( std::string const & type_name ) {
+        return "__cfatid_" + type_name;
+}
+
+static std::string typeIdTypeToInstance( std::string const & type_name ) {
+        return typeIdName(type_name.substr(16));
+}
+
 std::string vtableTypeName( std::string const & name ) {
         return name + "_vtable";
+}
+
+std::string baseTypeName( std::string const & vtable_type_name ) {
+        return vtable_type_name.substr(0, vtable_type_name.size() - 7);
 }
 
@@ -81 +97 @@
                                 inits.push_back(
                                                 new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
+                        } else if ( std::string( "__cfavir_typeid" ) == field->name ) {
+                                std::string const & baseType = baseTypeName( vtableType->name );
+                                std::string const & typeId = typeIdName( baseType );
+                                inits.push_back( new SingleInit( new AddressExpr( new NameExpr( typeId ) ) ) );
                         } else if ( std::string( "size" ) == field->name ) {
                                 inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
@@ -147 +167 @@
 }
 
+ObjectDecl * makeTypeIdForward() {
+        return nullptr;
 }
+
+Attribute * linkonce( const std::string & subsection ) {
+        const std::string section = ".gnu.linkonce." + subsection;
+        return new Attribute( "section", {
+                new ConstantExpr( Constant::from_string( section ) ),
+        } );
+}
+
+ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
+        assert( typeIdType );
+        StructInstType * type = typeIdType->clone();
+        type->tq.is_const = true;
+        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
+        return new ObjectDecl(
+                typeid_name,
+                noStorageClasses,
+                LinkageSpec::Cforall,
+                /* bitfieldWidth */ nullptr,
+                type,
+                new ListInit( { new SingleInit(
+                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
+                        ) } ),
+                { linkonce( typeid_name ) },
+                noFuncSpecifiers
+        );
+}
+
+}

src/Virtual/Tables.h

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:07:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep  1 14:29:00 2020
-// Update Count     : 0
+// Last Modified On : Thr Apr  8 15:55:00 2021
+// Update Count     : 1
 //
 
@@ -22 +22 @@
 namespace Virtual {
 
+std::string typeIdType( std::string const & type_name );
+std::string typeIdName( std::string const & type_name );
 std::string vtableTypeName( std::string const & type_name );
 std::string instanceName( std::string const & vtable_name );
@@ -50 +52 @@
  */
 
+ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType );
+/* Build an instance of the type-id from the type of the type-id.
+ * TODO: Should take the parent type. Currently locked to the exception_t.
+ */
+
 }