From 43c146794aab638924d2ab838d10f8af2ebf02a7 Mon Sep 17 00:00:00 2001 From: jsmall-nvidia Date: Fri, 5 Jun 2020 18:20:09 -0400 Subject: ASTNodes use MemoryArena (#1376) * Add a ASTBuilder to a Module Only construct on valid ASTBuilder (was being called on nullptr on occassion) * Add nodes to ASTBuilder. * Compiles with RefPtr removed from AST node types. * Initialize all AST node pointer variables in headers to nullptr; * Initialize AST node variables as nullptr. Make ASTBuilder keep a ref on node types. Make SyntaxParseCallback returns a NodeBase * Don't release canonicalType on dtor (managed by ASTBuilder). * Give ASTBuilders a name and id, to help in debugging. For now destroy the session TypeCache, to stop it holding things released when the compile request destroys ASTBuilders. * Moved the TypeCheckingCache over to Linkage from Session. * NodeBase no longer derived from RefObject. * Only add/dtor nodes that need destruction. First pass compile on linux. --- source/slang/slang-ast-builder.cpp | 91 ++++++++++++++++++++++---------------- 1 file changed, 53 insertions(+), 38 deletions(-) (limited to 'source/slang/slang-ast-builder.cpp') diff --git a/source/slang/slang-ast-builder.cpp b/source/slang/slang-ast-builder.cpp index 67ce80120..048ba7437 100644 --- a/source/slang/slang-ast-builder.cpp +++ b/source/slang/slang-ast-builder.cpp @@ -12,7 +12,6 @@ SharedASTBuilder::SharedASTBuilder() { } - void SharedASTBuilder::init(Session* session) { m_namePool = session->getNamePool(); @@ -55,14 +54,14 @@ const ReflectClassInfo* SharedASTBuilder::findClassInfo(const UnownedStringSlice return m_sliceToTypeMap.TryGetValue(slice, typeInfo) ? typeInfo : nullptr; } -SyntaxClass SharedASTBuilder::findSyntaxClass(const UnownedStringSlice& slice) +SyntaxClass SharedASTBuilder::findSyntaxClass(const UnownedStringSlice& slice) { const ReflectClassInfo* typeInfo; if (m_sliceToTypeMap.TryGetValue(slice, typeInfo)) { - return SyntaxClass(typeInfo); + return SyntaxClass(typeInfo); } - return SyntaxClass(); + return SyntaxClass(); } const ReflectClassInfo* SharedASTBuilder::findClassInfo(Name* name) @@ -71,14 +70,14 @@ const ReflectClassInfo* SharedASTBuilder::findClassInfo(Name* name) return m_nameToTypeMap.TryGetValue(name, typeInfo) ? typeInfo : nullptr; } -SyntaxClass SharedASTBuilder::findSyntaxClass(Name* name) +SyntaxClass SharedASTBuilder::findSyntaxClass(Name* name) { const ReflectClassInfo* typeInfo; if (m_nameToTypeMap.TryGetValue(name, typeInfo)) { - return SyntaxClass(typeInfo); + return SyntaxClass(typeInfo); } - return SyntaxClass(); + return SyntaxClass(); } Type* SharedASTBuilder::getStringType() @@ -106,7 +105,7 @@ SharedASTBuilder::~SharedASTBuilder() // Release built in types.. for (Index i = 0; i < SLANG_COUNT_OF(m_builtinTypes); ++i) { - m_builtinTypes[i].setNull(); + m_builtinTypes[i] = nullptr; } if (m_astBuilder) @@ -115,13 +114,13 @@ SharedASTBuilder::~SharedASTBuilder() } } -void SharedASTBuilder::registerBuiltinDecl(RefPtr decl, RefPtr modifier) +void SharedASTBuilder::registerBuiltinDecl(Decl* decl, BuiltinTypeModifier* modifier) { - auto type = DeclRefType::create(m_astBuilder, DeclRef(decl.Ptr(), nullptr)); + auto type = DeclRefType::create(m_astBuilder, DeclRef(decl, nullptr)); m_builtinTypes[Index(modifier->tag)] = type; } -void SharedASTBuilder::registerMagicDecl(RefPtr decl, RefPtr modifier) +void SharedASTBuilder::registerMagicDecl(Decl* decl, MagicTypeModifier* modifier) { // In some cases the modifier will have been applied to the // "inner" declaration of a `GenericDecl`, but what we @@ -131,55 +130,71 @@ void SharedASTBuilder::registerMagicDecl(RefPtr decl, RefPtr(decl->parentDecl)) declToRegister = genericDecl; - m_magicDecls[modifier->name] = declToRegister.Ptr(); + m_magicDecls[modifier->name] = declToRegister; } -RefPtr SharedASTBuilder::findMagicDecl(const String& name) +Decl* SharedASTBuilder::findMagicDecl(const String& name) { return m_magicDecls[name].GetValue(); } // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ASTBuilder !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! -ASTBuilder::ASTBuilder(SharedASTBuilder* sharedASTBuilder): - m_sharedASTBuilder(sharedASTBuilder) +ASTBuilder::ASTBuilder(SharedASTBuilder* sharedASTBuilder, const String& name): + m_sharedASTBuilder(sharedASTBuilder), + m_name(name), + m_id(sharedASTBuilder->m_id++), + m_arena(2048) { SLANG_ASSERT(sharedASTBuilder); } ASTBuilder::ASTBuilder(): - m_sharedASTBuilder(nullptr) + m_sharedASTBuilder(nullptr), + m_id(-1), + m_arena(2048) +{ + m_name = "ShadedASTBuilder::m_astBuilder"; +} + +ASTBuilder::~ASTBuilder() { + for (NodeBase* node : m_nodes) + { + const ReflectClassInfo* info = ReflectClassInfo::getInfo(node->astNodeType); + SLANG_ASSERT(info->m_destroyFunc); + info->m_destroyFunc(node); + } } -RefPtr ASTBuilder::getPtrType(RefPtr valueType) +PtrType* ASTBuilder::getPtrType(Type* valueType) { - return getPtrType(valueType, "PtrType").dynamicCast(); + return dynamicCast(getPtrType(valueType, "PtrType")); } // Construct the type `Out` -RefPtr ASTBuilder::getOutType(RefPtr valueType) +OutType* ASTBuilder::getOutType(Type* valueType) { - return getPtrType(valueType, "OutType").dynamicCast(); + return dynamicCast(getPtrType(valueType, "OutType")); } -RefPtr ASTBuilder::getInOutType(RefPtr valueType) +InOutType* ASTBuilder::getInOutType(Type* valueType) { - return getPtrType(valueType, "InOutType").dynamicCast(); + return dynamicCast(getPtrType(valueType, "InOutType")); } -RefPtr ASTBuilder::getRefType(RefPtr valueType) +RefType* ASTBuilder::getRefType(Type* valueType) { - return getPtrType(valueType, "RefType").dynamicCast(); + return dynamicCast(getPtrType(valueType, "RefType")); } -RefPtr ASTBuilder::getPtrType(RefPtr valueType, char const* ptrTypeName) +PtrTypeBase* ASTBuilder::getPtrType(Type* valueType, char const* ptrTypeName) { - auto genericDecl = m_sharedASTBuilder->findMagicDecl(ptrTypeName).dynamicCast(); + auto genericDecl = dynamicCast(m_sharedASTBuilder->findMagicDecl(ptrTypeName)); return getPtrType(valueType, genericDecl); } -RefPtr ASTBuilder::getPtrType(RefPtr valueType, GenericDecl* genericDecl) +PtrTypeBase* ASTBuilder::getPtrType(Type* valueType, GenericDecl* genericDecl) { auto typeDecl = genericDecl->inner; @@ -187,38 +202,38 @@ RefPtr ASTBuilder::getPtrType(RefPtr valueType, GenericDecl* substitutions->genericDecl = genericDecl; substitutions->args.add(valueType); - auto declRef = DeclRef(typeDecl.Ptr(), substitutions); + auto declRef = DeclRef(typeDecl, substitutions); auto rsType = DeclRefType::create(this, declRef); return as(rsType); } -RefPtr ASTBuilder::getArrayType(Type* elementType, IntVal* elementCount) +ArrayExpressionType* ASTBuilder::getArrayType(Type* elementType, IntVal* elementCount) { - RefPtr arrayType = create(); + ArrayExpressionType* arrayType = create(); arrayType->baseType = elementType; arrayType->arrayLength = elementCount; return arrayType; } -RefPtr ASTBuilder::getVectorType( - RefPtr elementType, - RefPtr elementCount) +VectorExpressionType* ASTBuilder::getVectorType( + Type* elementType, + IntVal* elementCount) { - auto vectorGenericDecl = m_sharedASTBuilder->findMagicDecl("Vector").as(); + auto vectorGenericDecl = as(m_sharedASTBuilder->findMagicDecl("Vector")); auto vectorTypeDecl = vectorGenericDecl->inner; auto substitutions = create(); - substitutions->genericDecl = vectorGenericDecl.Ptr(); + substitutions->genericDecl = vectorGenericDecl; substitutions->args.add(elementType); substitutions->args.add(elementCount); - auto declRef = DeclRef(vectorTypeDecl.Ptr(), substitutions); + auto declRef = DeclRef(vectorTypeDecl, substitutions); - return DeclRefType::create(this, declRef).as(); + return as(DeclRefType::create(this, declRef)); } -RefPtr ASTBuilder::getTypeType(Type* type) +TypeType* ASTBuilder::getTypeType(Type* type) { return create(type); } -- cgit v1.2.3