Changeset 8e4bc30 for src/Virtual/Tables.cc

Timestamp:

Oct 8, 2020, 12:45:43 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:

8fc9a5f, baee756

Parents:

391c065 (diff), 6fbe9a5 (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/Virtual/Tables.cc (modified) (5 diffs)

src/Virtual/Tables.cc

@@ -14 +14 @@
 //
 
+#include <SynTree/Attribute.h>
 #include <SynTree/Declaration.h>
 #include <SynTree/Expression.h>
+#include <SynTree/Statement.h>
 #include <SynTree/Type.h>
 
@@ -38 +40 @@
 }
 
-// Fuse base polymorphic declaration and forall arguments into a new type.
-static StructInstType * vtableInstType(
-                StructDecl * polyDecl, std::list< Expression * > && parameters ) {
-        assert( parameters.size() == polyDecl->parameters.size() );
-        StructInstType * type = new StructInstType(
-                        Type::Qualifiers( /* Type::Const */ ), polyDecl );
-        type->parameters = std::move( parameters );
-        return type;
-}
-
 static ObjectDecl * makeVtableDeclaration(
                 StructInstType * type, Initializer * init ) {
@@ -66 +58 @@
 
 ObjectDecl * makeVtableForward( StructInstType * type ) {
+        assert( type );
         return makeVtableDeclaration( type, nullptr );
 }
 
-ObjectDecl * makeVtableForward(
-                StructDecl * polyDecl, std::list< Expression * > && parameters ) {
-        return makeVtableForward( vtableInstType( polyDecl, std::move( parameters ) ) );
-}
-
 ObjectDecl * makeVtableInstance(
-                StructInstType * vtableType, Type * vobject_type, Initializer * init ) {
+                StructInstType * vtableType, Type * objectType, Initializer * init ) {
+        assert( vtableType );
+        assert( objectType );
         StructDecl * vtableStruct = vtableType->baseStruct;
         // Build the initialization
@@ -92 +82 @@
                                                 new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
                         } else if ( std::string( "size" ) == field->name ) {
-                                inits.push_back( new SingleInit( new SizeofExpr( vobject_type->clone() ) ) );
+                                inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
                         } else if ( std::string( "align" ) == field->name ) {
-                                inits.push_back( new SingleInit( new AlignofExpr( vobject_type->clone() ) ) );
+                                inits.push_back( new SingleInit( new AlignofExpr( objectType->clone() ) ) );
                         } else {
                                 inits.push_back( new SingleInit( new NameExpr( field->name ) ) );
@@ -108 +98 @@
 }
 
-ObjectDecl * makeVtableInstance(
-                StructDecl * polyDecl, std::list< Expression * > && parameters,
-                Type * vobject, Initializer * init ) {
-        return makeVtableInstance(
-                vtableInstType( polyDecl, std::move( parameters ) ), vobject, init );
+namespace {
+        std::string const functionName = "get_exception_vtable";
+}
+
+FunctionDecl * makeGetExceptionForward(
+                Type * vtableType, Type * exceptType ) {
+        assert( vtableType );
+        assert( exceptType );
+        FunctionType * type = new FunctionType( noQualifiers, false );
+        vtableType->tq.is_const = true;
+        type->returnVals.push_back( new ObjectDecl(
+                "_retvalue",
+                noStorageClasses,
+                LinkageSpec::Cforall,
+                nullptr,
+                new ReferenceType( noQualifiers, vtableType ),
+                nullptr,
+        { new Attribute("unused") }
+        ) );
+        type->parameters.push_back( new ObjectDecl(
+                "__unused",
+                noStorageClasses,
+                LinkageSpec::Cforall,
+                nullptr,
+                new PointerType( noQualifiers, exceptType ),
+                nullptr,
+                { new Attribute("unused") }
+        ) );
+        return new FunctionDecl(
+                functionName,
+                noStorageClasses,
+                LinkageSpec::Cforall,
+                type,
+                nullptr
+        );
+}
+
+FunctionDecl * makeGetExceptionFunction(
+                ObjectDecl * vtableInstance, Type * exceptType ) {
+        assert( vtableInstance );
+        assert( exceptType );
+        FunctionDecl * func = makeGetExceptionForward(
+                vtableInstance->type->clone(), exceptType );
+        func->statements = new CompoundStmt( {
+                new ReturnStmt( new VariableExpr( vtableInstance ) ),
+        } );
+        return func;
 }