Changeset 4f6dda0 for src/Virtual

Timestamp:

Mar 11, 2022, 11:08:19 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

630c4bb

Parents:

b053083

Message:

Converted Implement Concurrent Keywords to the new AST. Includes updates to various helpers, including the virtual table and a lot of examine helpers.

Location:

src/Virtual

Files:

• Tables.cc (modified) (7 diffs)
• Tables.h (modified) (6 diffs)

src/Virtual/Tables.cc

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:11:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 21 15:36:00 2021
-// Update Count     : 2
-//
-
+// Last Modified On : Fri Mar 11 10:40:00 2022
+// Update Count     : 3
+//
+
+#include "AST/Attribute.hpp"
+#include "AST/Copy.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include <SynTree/Attribute.h>
 #include <SynTree/Declaration.h>
@@ -77 +84 @@
 }
 
+static ast::ObjectDecl * makeVtableDeclaration(
+                CodeLocation const & location, std::string const & name,
+                ast::StructInstType const * type, ast::Init const * init ) {
+        ast::Storage::Classes storage;
+        if ( nullptr == init ) {
+                storage.is_extern = true;
+        }
+        return new ast::ObjectDecl(
+                location,
+                name,
+                type,
+                init,
+                storage,
+                ast::Linkage::Cforall
+        );
+}
+
 ObjectDecl * makeVtableForward( std::string const & name, StructInstType * type ) {
         assert( type );
         return makeVtableDeclaration( name, type, nullptr );
+}
+
+ast::ObjectDecl * makeVtableForward(
+                CodeLocation const & location, std::string const & name,
+                ast::StructInstType const * vtableType ) {
+        assert( vtableType );
+        return makeVtableDeclaration( location, name, vtableType, nullptr );
 }
 
@@ -123 +154 @@
 }
 
+static std::vector<ast::ptr<ast::Init>> buildInits(
+                CodeLocation const & location,
+                //std::string const & name,
+                ast::StructInstType const * vtableType,
+                ast::Type const * objectType ) {
+        ast::StructDecl const * vtableStruct = vtableType->base;
+
+        std::vector<ast::ptr<ast::Init>> inits;
+        inits.reserve( vtableStruct->members.size() );
+
+        // This is designed to run before the resolver.
+        for ( auto field : vtableStruct->members ) {
+                if ( std::string( "parent" ) == field->name ) {
+                        // This will not work with polymorphic state.
+                        auto oField = field.strict_as<ast::ObjectDecl>();
+                        auto fieldType = oField->type.strict_as<ast::PointerType>();
+                        auto parentType = fieldType->base.strict_as<ast::StructInstType>();
+                        std::string const & parentInstance = instanceName( parentType->name );
+                        inits.push_back(
+                                        new ast::SingleInit( location, new ast::AddressExpr( new ast::NameExpr( location, 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 ast::SingleInit( location, new ast::AddressExpr( new ast::NameExpr( location, typeId ) ) ) );
+                } else if ( std::string( "size" ) == field->name ) {
+                        inits.push_back( new ast::SingleInit( location, new ast::SizeofExpr( location, objectType )
+                        ) );
+                } else if ( std::string( "align" ) == field->name ) {
+                        inits.push_back( new ast::SingleInit( location,
+                                new ast::AlignofExpr( location, objectType )
+                        ) );
+                } else {
+                        inits.push_back( new ast::SingleInit( location,
+                                new ast::NameExpr( location, field->name )
+                        ) );
+                }
+                //ast::Expr * expr = buildInitExpr(...);
+                //inits.push_back( new ast::SingleInit( location, expr ) )
+        }
+
+        return inits;
+}
+
+ast::ObjectDecl * makeVtableInstance(
+                CodeLocation const & location,
+                std::string const & name,
+                ast::StructInstType const * vtableType,
+                ast::Type const * objectType,
+                ast::Init const * init ) {
+        assert( vtableType );
+        assert( objectType );
+
+        // Build the initialization.
+        if ( nullptr == init ) {
+                init = new ast::ListInit( location,
+                        buildInits( location, vtableType, objectType ) );
+
+        // The provided init should initialize everything except the parent
+        // pointer, the size-of and align-of fields. These should be inserted.
+        } else {
+                // Except this is not yet supported.
+                assert(false);
+        }
+        return makeVtableDeclaration( location, name, vtableType, init );
+}
+
 namespace {
         std::string const functionName = "get_exception_vtable";
@@ -140 +237 @@
                 new ReferenceType( noQualifiers, vtableType ),
                 nullptr,
-        { new Attribute("unused") }
+                { new Attribute("unused") }
         ) );
         type->parameters.push_back( new ObjectDecl(
@@ -157 +254 @@
                 type,
                 nullptr
+        );
+}
+
+ast::FunctionDecl * makeGetExceptionForward(
+                CodeLocation const & location,
+                ast::Type const * vtableType,
+                ast::Type const * exceptType ) {
+        assert( vtableType );
+        assert( exceptType );
+        return new ast::FunctionDecl(
+                location,
+                functionName,
+                { /* forall */ },
+                { new ast::ObjectDecl(
+                        location,
+                        "__unused",
+                        new ast::PointerType( exceptType )
+                ) },
+                { new ast::ObjectDecl(
+                        location,
+                        "_retvalue",
+                        new ast::ReferenceType( vtableType )
+                ) },
+                nullptr,
+                ast::Storage::Classes(),
+                ast::Linkage::Cforall,
+                { new ast::Attribute( "unused" ) }
         );
 }
@@ -172 +296 @@
 }
 
+ast::FunctionDecl * makeGetExceptionFunction(
+                CodeLocation const & location,
+                ast::ObjectDecl const * vtableInstance, ast::Type const * exceptType ) {
+        assert( vtableInstance );
+        assert( exceptType );
+        ast::FunctionDecl * func = makeGetExceptionForward(
+                        location, ast::deepCopy( vtableInstance->type ), exceptType );
+        func->stmts = new ast::CompoundStmt( location, {
+                new ast::ReturnStmt( location, new ast::VariableExpr( location, vtableInstance ) )
+        } );
+        return func;
+}
+
 ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
         assert( typeIdType );
@@ -191 +328 @@
 }
 
-}
+ast::ObjectDecl * makeTypeIdInstance(
+                CodeLocation const & location,
+                ast::StructInstType const * typeIdType ) {
+        assert( typeIdType );
+        ast::StructInstType * type = ast::mutate( typeIdType );
+        type->set_const( true );
+        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
+        return new ast::ObjectDecl(
+                location,
+                typeid_name,
+                type,
+                new ast::ListInit( location, {
+                        new ast::SingleInit( location,
+                                new ast::AddressExpr( location,
+                                        new ast::NameExpr( location, "__cfatid_exception_t" ) ) )
+                } ),
+                ast::Storage::Classes(),
+                ast::Linkage::Cforall,
+                nullptr,
+                { new ast::Attribute( "cfa_linkonce" ) }
+        );
+}
+
+}

src/Virtual/Tables.h

@@ -10 +10 @@
 // Created On       : Mon Aug 31 11:07:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 21 10:30:00 2021
-// Update Count     : 2
+// Last Modified On : Wec Dec  8 16:58:00 2021
+// Update Count     : 3
 //
 
 #include <list>  // for list
 
+#include <string>
+#include "AST/Fwd.hpp"
 class Declaration;
 class StructDecl;
@@ -35 +37 @@
  * vtableType node is consumed.
  */
+ast::ObjectDecl * makeVtableForward(
+        CodeLocation const & location, std::string const & name,
+        ast::StructInstType const * vtableType );
 
 ObjectDecl * makeVtableInstance(
@@ -43 +48 @@
  * vtableType and init (if provided) nodes are consumed.
  */
+ast::ObjectDecl * makeVtableInstance(
+        CodeLocation const & location,
+        std::string const & name,
+        ast::StructInstType const * vtableType,
+        ast::Type const * objectType,
+        ast::Init const * init = nullptr );
 
 // Some special code for how exceptions interact with virtual tables.
@@ -49 +60 @@
  * linking the vtableType to the exceptType. Both nodes are consumed.
  */
+ast::FunctionDecl * makeGetExceptionForward(
+        CodeLocation const & location,
+        ast::Type const * vtableType,
+        ast::Type const * exceptType );
 
 FunctionDecl * makeGetExceptionFunction(
@@ -55 +70 @@
  * exceptType node is consumed.
  */
+ast::FunctionDecl * makeGetExceptionFunction(
+        CodeLocation const & location,
+        ast::ObjectDecl const * vtableInstance, ast::Type const * exceptType );
 
 ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType );
@@ -60 +78 @@
  * TODO: Should take the parent type. Currently locked to the exception_t.
  */
+ast::ObjectDecl * makeTypeIdInstance(
+        const CodeLocation & location, ast::StructInstType const * typeIdType );
 
 }