Changeset ecfd758 for src/Virtual/ExpandCasts.cc

Timestamp:

Apr 9, 2021, 2:11:43 PM (16 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

b91bfde

Parents:

e07b589

Message:

Major exception update, seperating type-ids from virtual tables. The major interface changes are done. There is a regression of ?Cancelled(T) to Some?Cancelled. There is some bits of code for the new verion of the ?Cancelled(T) interface already there. Not connected yet but I just reached the limit of what I wanted to do in one commit and then spent over a day cleaning up, so it will replace Some?Cancelled in a future commit.

File:

• src/Virtual/ExpandCasts.cc (modified) (7 diffs)

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) {
@@ -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." );
                 }
 
@@ -238 +254 @@
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
                                         new CastExpr(
-                                                new AddressExpr( new VariableExpr( table ) ),
+                                                new AddressExpr( new VariableExpr( type_id ) ),
                                                 pointer_to_pvt(1)
                                         ),
@@ -252 +268 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
-                delete vtable_type;
                 return result;
         }