Changeset 5af7306 for src

Timestamp:

Apr 23, 2018, 4:46:43 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

2efe4b8

Parents:

fb97252f

Message:

Assorted bug fixes

Location:

src

Files:

• Common/GC.cc (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (2 diffs)
• SynTree/GcTracer.h (modified) (1 diff)

src/Common/GC.cc

@@ -57 +57 @@
 //     set variable GC_TRAP_OBJ = <target>
 //     disable <first breakpoint>
+//     continue
 #ifdef GC_TRAP
 #include <csignal>

src/InitTweak/GenInit.cc

@@ -258 +258 @@
                                         // generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that
                                         // polymorphic constructors make generic types managed types
-                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
-                                        managedTypes.insert( SymTab::Mangler::mangleConcrete( &inst ) );
+                                        auto inst = new StructInstType( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangleConcrete( inst ) );
                                         break;
                                 }

src/ResolvExpr/AlternativeFinder.cc

@@ -1082 +1082 @@
                 AlternativeFinder funcOpFinder( indexer, env );
                 // it's ok if there aren't any defined function ops
-                funcOpFinder.maybeFind( opExpr);
+                funcOpFinder.maybeFind( opExpr );
                 PRINT(
                         std::cerr << "known function ops:" << std::endl;

src/ResolvExpr/ConversionCost.cc

@@ -20 +20 @@
 #include <string>                        // for operator==, string
 
+#include "Common/GC.h"                   // for new_static_root
 #include "ResolvExpr/Cost.h"             // for Cost
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
@@ -353 +354 @@
         void ConversionCost::postvisit( EnumInstType * ) {
                 static Type::Qualifiers q;
-                static BasicType integer( q, BasicType::SignedInt );
-                cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
+                static BasicType* integer = new_static_root<BasicType>( q, BasicType::SignedInt );
+                cost = costFunc( integer, dest, indexer, env );  // safe if dest >= int
                 if ( cost < Cost::unsafe ) {
                         cost.incSafe();

src/SymTab/Validate.cc

@@ -48 +48 @@
 #include "CodeGen/CodeGenerator.h"     // for genName
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
+#include "Common/GC.h"                 // for new_static_root, register_static_root
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
@@ -673 +674 @@
                         // grab and remember declaration of size_t
                         SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
+                        GC::get().register_static_root( SizeType );
                 } else {
                         // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
                         // eventually should have a warning for this case.
-                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                        SizeType = 
+                                new_static_root<BasicType>( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 }
                 filter( translationUnit, isTypedef );

src/SynTree/GcTracer.h

@@ -53 +53 @@
         }
 
+        void postvisit( DeclarationWithType* decl ) {
+                maybeAccept( decl->asmName, *visitor );
+        }
+
+private:
+        void visit( InferredParams& inferParams ) {
+                for ( auto& entry : inferParams ) {
+                        maybeAccept( entry.second.actualType, *visitor );
+                        maybeAccept( entry.second.formalType, *visitor );
+                        maybeAccept( entry.second.expr, *visitor );
+                        visit( *entry.second.inferParams );
+                }
+        }
+
+public:
         void postvisit( Expression* expr ) {
                 maybeAccept( expr->env, *visitor );
+                visit( expr->inferParams );
         }