source: src/Virtual/Tables.cc @ ecfd758

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since ecfd758 was ecfd758, checked in by Andrew Beach <ajbeach@…>, 6 months ago

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.

  • Property mode set to 100644
File size: 6.0 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Tables.cc --
8//
9// Author           : Andrew Beach
10// Created On       : Mon Aug 31 11:11:00 2020
11// Last Modified By : Andrew Beach
12// Last Modified On : Thr Apr  8 15:51:00 2021
13// Update Count     : 1
14//
15
16#include <SynTree/Attribute.h>
17#include <SynTree/Declaration.h>
18#include <SynTree/Expression.h>
19#include <SynTree/Statement.h>
20#include <SynTree/Type.h>
21
22namespace Virtual {
23
24std::string typeIdType( std::string const & type_name ) {
25        return "__cfatid_struct_" + type_name;
26}
27
28std::string typeIdName( std::string const & type_name ) {
29        return "__cfatid_" + type_name;
30}
31
32static std::string typeIdTypeToInstance( std::string const & type_name ) {
33        return typeIdName(type_name.substr(16));
34}
35
36std::string vtableTypeName( std::string const & name ) {
37        return name + "_vtable";
38}
39
40std::string baseTypeName( std::string const & vtable_type_name ) {
41        return vtable_type_name.substr(0, vtable_type_name.size() - 7);
42}
43
44std::string instanceName( std::string const & name ) {
45        return std::string("_") + name + "_instance";
46}
47
48std::string vtableInstanceName( std::string const & name ) {
49        return instanceName( vtableTypeName( name ) );
50}
51
52bool isVTableInstanceName( std::string const & name ) {
53        // There are some delicate length calculations here.
54        return 17 < name.size() && '_' == name[0] &&
55                std::string("_vtable_instance") == name.substr(1, name.size() - 17);
56}
57
58static ObjectDecl * makeVtableDeclaration(
59                StructInstType * type, Initializer * init ) {
60        std::string const & name = instanceName( type->name );
61        Type::StorageClasses storage = noStorageClasses;
62        if ( nullptr == init ) {
63                storage.is_extern = true;
64        }
65        return new ObjectDecl(
66                name,
67                storage,
68                LinkageSpec::Cforall,
69                nullptr,
70                type,
71                init
72        );
73}
74
75ObjectDecl * makeVtableForward( StructInstType * type ) {
76        assert( type );
77        return makeVtableDeclaration( type, nullptr );
78}
79
80ObjectDecl * makeVtableInstance(
81                StructInstType * vtableType, Type * objectType, Initializer * init ) {
82        assert( vtableType );
83        assert( objectType );
84        StructDecl * vtableStruct = vtableType->baseStruct;
85        // Build the initialization
86        if ( nullptr == init ) {
87                std::list< Initializer * > inits;
88
89                // This is going to have to be run before the resolver to connect expressions.
90                for ( auto field : vtableStruct->members ) {
91                        if ( std::string( "parent" ) == field->name ) {
92                                // This will not work with polymorphic state.
93                                auto oField = strict_dynamic_cast< ObjectDecl * >( field );
94                                auto fieldType = strict_dynamic_cast< PointerType * >( oField->type );
95                                auto parentType = strict_dynamic_cast< StructInstType * >( fieldType->base );
96                                std::string const & parentInstance = instanceName( parentType->name );
97                                inits.push_back(
98                                                new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
99                        } else if ( std::string( "__cfavir_typeid" ) == field->name ) {
100                                std::string const & baseType = baseTypeName( vtableType->name );
101                                std::string const & typeId = typeIdName( baseType );
102                                inits.push_back( new SingleInit( new AddressExpr( new NameExpr( typeId ) ) ) );
103                        } else if ( std::string( "size" ) == field->name ) {
104                                inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
105                        } else if ( std::string( "align" ) == field->name ) {
106                                inits.push_back( new SingleInit( new AlignofExpr( objectType->clone() ) ) );
107                        } else {
108                                inits.push_back( new SingleInit( new NameExpr( field->name ) ) );
109                        }
110                }
111                init = new ListInit( inits );
112        // This should initialize everything except the parent pointer, the
113        // size-of and align-of fields. These should be inserted.
114        } else {
115                assert(false);
116        }
117        return makeVtableDeclaration( vtableType, init );
118}
119
120namespace {
121        std::string const functionName = "get_exception_vtable";
122}
123
124FunctionDecl * makeGetExceptionForward(
125                Type * vtableType, Type * exceptType ) {
126        assert( vtableType );
127        assert( exceptType );
128        FunctionType * type = new FunctionType( noQualifiers, false );
129        vtableType->tq.is_const = true;
130        type->returnVals.push_back( new ObjectDecl(
131                "_retvalue",
132                noStorageClasses,
133                LinkageSpec::Cforall,
134                nullptr,
135                new ReferenceType( noQualifiers, vtableType ),
136                nullptr,
137        { new Attribute("unused") }
138        ) );
139        type->parameters.push_back( new ObjectDecl(
140                "__unused",
141                noStorageClasses,
142                LinkageSpec::Cforall,
143                nullptr,
144                new PointerType( noQualifiers, exceptType ),
145                nullptr,
146                { new Attribute("unused") }
147        ) );
148        return new FunctionDecl(
149                functionName,
150                noStorageClasses,
151                LinkageSpec::Cforall,
152                type,
153                nullptr
154        );
155}
156
157FunctionDecl * makeGetExceptionFunction(
158                ObjectDecl * vtableInstance, Type * exceptType ) {
159        assert( vtableInstance );
160        assert( exceptType );
161        FunctionDecl * func = makeGetExceptionForward(
162                vtableInstance->type->clone(), exceptType );
163        func->statements = new CompoundStmt( {
164                new ReturnStmt( new VariableExpr( vtableInstance ) ),
165        } );
166        return func;
167}
168
169ObjectDecl * makeTypeIdForward() {
170        return nullptr;
171}
172
173Attribute * linkonce( const std::string & subsection ) {
174        const std::string section = "\".gnu.linkonce." + subsection + "\"";
175        // Adjust for terminator and quotes.
176        size_t str_size = section.size() + 1 - 2;
177        return new Attribute( "section", {
178                new ConstantExpr( Constant(
179                        new ArrayType(
180                                noQualifiers,
181                                new BasicType( noQualifiers, BasicType::Char ),
182                                new ConstantExpr( Constant::from_ulong( str_size ) ),
183                                false, false ),
184                        section,
185                        std::nullopt
186                ) ),
187        } );
188}
189
190ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
191        assert( typeIdType );
192        StructInstType * type = typeIdType->clone();
193        type->tq.is_const = true;
194        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
195        return new ObjectDecl(
196                typeid_name,
197                noStorageClasses,
198                LinkageSpec::Cforall,
199                /* bitfieldWidth */ nullptr,
200                type,
201                new ListInit( { new SingleInit(
202                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
203                        ) } ),
204                { linkonce( typeid_name ) },
205                noFuncSpecifiers
206        );
207}
208
209}
Note: See TracBrowser for help on using the repository browser.