Changeset 5b7a60c8

Timestamp:

Aug 18, 2016, 5:00:32 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

12756de

Parents:

99cad3aa (diff), 7ecbb7e (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 plg2:software/cfa/cfa-cc

Location:

src

Files:

• Common/utility.h (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (9 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (9 diffs)
• examples/gc_no_raii/containers/vector (added)
• examples/gc_no_raii/containers/vector.c (added)
• examples/gc_no_raii/premake4.lua (modified) (2 diffs)
• examples/gc_no_raii/src/gc.h (modified) (1 diff)
• examples/gc_no_raii/src/gcpointers.c (modified) (5 diffs)
• examples/gc_no_raii/src/gcpointers.h (modified) (2 diffs)
• examples/gc_no_raii/src/internal/collector.c (modified) (2 diffs)
• examples/gc_no_raii/src/internal/state.h (modified) (2 diffs)
• examples/gc_no_raii/test/gctest.c (modified) (2 diffs)

src/Common/utility.h

@@ -49 +49 @@
 }
 
+template< typename T, typename U >
+static inline T * maybeMoveBuild( const U *orig ) {
+        T* ret = maybeBuild<T>(orig);
+        delete orig;
+        return ret;
+}
+
+
 template< typename Input_iterator >
 void printEnums( Input_iterator begin, Input_iterator end, const char * const *name_array, std::ostream &os ) {

src/Parser/ExpressionNode.cc

@@ -167 +167 @@
 
 NameExpr * build_varref( const string *name, bool labelp ) {
-        return new NameExpr( *name, nullptr );
+        NameExpr *expr = new NameExpr( *name, nullptr );
+        delete name;
+        return expr;
 }
 
@@ -184 +186 @@
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
-                return new CastExpr( maybeBuild< Expression >(expr_node) );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
         } else {
-                return new CastExpr( maybeBuild< Expression >(expr_node), targetType );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
         } // if
 }
 
 Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild< Expression >(expr_node) );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeMoveBuild< Expression >(expr_node) );
         delete member;
         return ret;
@@ -198 +200 @@
 Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-        deref->get_args().push_back( maybeBuild< Expression >(expr_node) );
+        deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
         UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
         delete member;
@@ -205 +207 @@
 
 Expression *build_addressOf( ExpressionNode *expr_node ) {
-                return new AddressExpr( maybeBuild< Expression >(expr_node) );
+                return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
 }
 Expression *build_sizeOfexpr( ExpressionNode *expr_node ) {
-        return new SizeofExpr( maybeBuild< Expression >(expr_node) );
+        return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
 }
 Expression *build_sizeOftype( DeclarationNode *decl_node ) {
@@ -214 +216 @@
 }
 Expression *build_alignOfexpr( ExpressionNode *expr_node ) {
-        return new AlignofExpr( maybeBuild< Expression >(expr_node) );
+        return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
 }
 Expression *build_alignOftype( DeclarationNode *decl_node ) {
@@ -224 +226 @@
 
 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
-        return new LogicalExpr( notZeroExpr( maybeBuild< Expression >(expr_node1) ), notZeroExpr( maybeBuild< Expression >(expr_node2) ), kind );
+        return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
 }
 
 Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
         std::list< Expression * > args;
-        args.push_back( maybeBuild< Expression >(expr_node) );
+        args.push_back( maybeMoveBuild< Expression >(expr_node) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
         std::list< Expression * > args;
-        args.push_back( new AddressExpr( maybeBuild< Expression >(expr_node) ) );
+        args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         std::list< Expression * > args;
-        args.push_back( maybeBuild< Expression >(expr_node1) );
-        args.push_back( maybeBuild< Expression >(expr_node2) );
+        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
+        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
         std::list< Expression * > args;
-        args.push_back( new AddressExpr( maybeBuild< Expression >(expr_node1) ) );
-        args.push_back( maybeBuild< Expression >(expr_node2) );
+        args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) );
+        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 
 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
-        return new ConditionalExpr( notZeroExpr( maybeBuild< Expression >(expr_node1) ), maybeBuild< Expression >(expr_node2), maybeBuild< Expression >(expr_node3) );
+        return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
 }
 
 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-        return new CommaExpr( maybeBuild< Expression >(expr_node1), maybeBuild< Expression >(expr_node2) );
+        return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) );
 }
 
 Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {
-        return new AttrExpr( var, maybeBuild< Expression >(expr_node) );
+        return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
 }
 Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) {
@@ -267 +269 @@
 Expression *build_tuple( ExpressionNode * expr_node ) {
         TupleExpr *ret = new TupleExpr();
-        buildList( expr_node, ret->get_exprs() );
+        buildMoveList( expr_node, ret->get_exprs() );
         return ret;
 }
@@ -273 +275 @@
 Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
-
-        buildList( expr_node, args );
-        return new UntypedExpr( maybeBuild< Expression >(function), args, nullptr );
+        buildMoveList( expr_node, args );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
 }
 
 Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
-        Expression *low_cexpr = maybeBuild< Expression >( low );
-        Expression *high_cexpr = maybeBuild< Expression >( high );
-        return new RangeExpr( low_cexpr, high_cexpr );
+        return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
 }
 
 Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
-        return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild< Expression >(operand) );
+        return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
 }
 
 Expression *build_valexpr( StatementNode *s ) {
-        return new UntypedValofExpr( maybeBuild< Statement >(s), nullptr );
+        return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr );
 }
 Expression *build_typevalue( DeclarationNode *decl ) {
@@ -298 +297 @@
         Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
-                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild< Initializer >(kids) );
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
         // these types do not have associated type information
         } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild< Initializer >(kids) );
+                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
         } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild< Initializer >(kids) );
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
         } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild< Initializer >(kids) );
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
         } else {
                 assert( false );

src/Parser/ParseNode.h

@@ -387 +387 @@
 void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
 
+template< typename SynTreeType, typename NodeType >
+void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
+        buildList(firstNode, outputList);
+        delete firstNode;
+}
+
+
 #endif // PARSENODE_H
 

src/Parser/StatementNode.cc

@@ -62 +62 @@
         StatementNode *node = dynamic_cast< StatementNode * >(prev);
         std::list< Statement * > stmts;
-        buildList( stmt, stmts );
+        buildMoveList( stmt, stmts );
         // splice any new Statements to end of current Statements
         CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt);
@@ -70 +70 @@
 
 Statement *build_expr( ExpressionNode *ctl ) {
-        Expression *e = maybeBuild< Expression >( ctl );
+        Expression *e = maybeMoveBuild< Expression >( ctl );
 
         if ( e )
@@ -81 +81 @@
         Statement *thenb, *elseb = 0;
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( then_stmt, branches );
+        buildMoveList< Statement, StatementNode >( then_stmt, branches );
         assert( branches.size() == 1 );
         thenb = branches.front();
@@ -87 +87 @@
         if ( else_stmt ) {
                 std::list< Statement * > branches;
-                buildList< Statement, StatementNode >( else_stmt, branches );
+                buildMoveList< Statement, StatementNode >( else_stmt, branches );
                 assert( branches.size() == 1 );
                 elseb = branches.front();
         } // if
-        return new IfStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), thenb, elseb );
+        return new IfStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), thenb, elseb );
 }
 
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() >= 0 );                                         // size == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( noLabels, maybeBuild< Expression >(ctl), branches );
+        return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
         std::list< Statement * > branches;
-        return new CaseStmt( noLabels, maybeBuild< Expression >(ctl), branches );
+        return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
@@ -111 +111 @@
 Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new WhileStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), branches.front(), kind );
+        return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
 Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
 
         std::list< Statement * > init;
         if ( forctl->init != 0 ) {
-                buildList( forctl->init, init );
+                buildMoveList( forctl->init, init );
         } // if
 
         Expression *cond = 0;
         if ( forctl->condition != 0 )
-                cond = notZeroExpr( maybeBuild< Expression >(forctl->condition) );
+                cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
 
         Expression *incr = 0;
         if ( forctl->change != 0 )
-                incr = maybeBuild< Expression >(forctl->change);
+                incr = maybeMoveBuild< Expression >(forctl->change);
 
         delete forctl;
@@ -142 +142 @@
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-        return new BranchStmt( noLabels, maybeBuild< Expression >(ctl), BranchStmt::Goto );
+        return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
 Statement *build_return( ExpressionNode *ctl ) {
         std::list< Expression * > exps;
-        buildList( ctl, exps );
+        buildMoveList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
 }
 Statement *build_throw( ExpressionNode *ctl ) {
         std::list< Expression * > exps;
-        buildList( ctl, exps );
+        buildMoveList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true );
 }
@@ -158 +158 @@
 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( catch_stmt, branches );
-        CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeBuild< Statement >(try_stmt));
+        buildMoveList< Statement, StatementNode >( catch_stmt, branches );
+        CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
         assert( tryBlock );
-        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeBuild< Statement >(finally_stmt) );
+        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
         return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new CatchStmt( noLabels, maybeBuild< Declaration >(decl), branches.front(), catchAny );
+        return new CatchStmt( noLabels, maybeMoveBuild< Declaration >(decl), branches.front(), catchAny );
 }
 Statement *build_finally( StatementNode *stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
         return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
@@ -179 +179 @@
 Statement *build_compound( StatementNode *first ) {
         CompoundStmt *cs = new CompoundStmt( noLabels );
-        buildList( first, cs->get_kids() );
+        buildMoveList( first, cs->get_kids() );
         return cs;
 }
@@ -187 +187 @@
         std::list< ConstantExpr * > clob;
 
-        buildList( output, out );
-        buildList( input, in );
-        buildList( clobber, clob );
+        buildMoveList( output, out );
+        buildMoveList( input, in );
+        buildMoveList( clobber, clob );
         return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
 }

src/examples/gc_no_raii/premake4.lua

@@ -6 +6 @@
         "src/",
         "../",
+        "containers/"
 }
 
@@ -48 +49 @@
                 linkoptions (linkOptionList)
                 includedirs (includeDirList)
-                files { "src/**.c" }
+                files { "src/**.c", "containers/**.c" }
 
         configuration "debug"

src/examples/gc_no_raii/src/gc.h

@@ -4 +4 @@
 #include "internal/collector.h"
 
-forall(otype T)
-static inline gcpointer(T) gcmalloc()
-{
-    gcpointer(T) ptr = { gc_allocate(sizeof(T)) };
-    ptr{};
-    gc_conditional_collect();
-    return ptr;
-}
+// forall(otype T)
+// static inline gcpointer(T) gcmalloc()
+// {
+//     gcpointer(T) ptr = { gc_allocate(sizeof(T)) };
+//     ptr{};
+//     gc_conditional_collect();
+//     return ptr;
+// }
 
 forall(otype T)
 static inline void gcmalloc(gcpointer(T)* ptr)
 {
-        ptr{ gc_allocate(sizeof(T)) };
-      (*ptr){};
+        ptr { gc_allocate(sizeof(T)) };
+        get(ptr) {};
       gc_conditional_collect();
 }

src/examples/gc_no_raii/src/gcpointers.c

@@ -42 +42 @@
 }
 
-void gcpointer_ctor(gcpointer_t* this)
+void ?{}(gcpointer_t* this)
 {
         this->ptr = (intptr_t)NULL;
@@ -48 +48 @@
 }
 
-void gcpointer_ctor(gcpointer_t* this, void* address)
+void ?{}(gcpointer_t* this, void* address)
 {
         this->ptr = (intptr_t)address;
@@ -56 +56 @@
 }
 
-void gcpointer_ctor(gcpointer_t* this, gcpointer_t* other)
+void ?{}(gcpointer_t* this, gcpointer_t other)
 {
-        this->ptr = other->ptr;
+        this->ptr = other.ptr;
         this->next = NULL;
 
@@ -64 +64 @@
 }
 
-void gcpointer_dtor(gcpointer_t* this)
+void ^?{}(gcpointer_t* this)
 {
         unregister_ptr(this);
@@ -98 +98 @@
         return this->ptr == (intptr_t)NULL;
 }
+
+forall(otype T) void ?{}(gcpointer(T)* this) {
+        (&this->internal) {};
+}
+
+forall(otype T) void ?{}(gcpointer(T)* this, void* address) {
+        (&this->internal) { address };
+}
+
+forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other) {
+        (&this->internal) { other->internal };
+}
+
+forall(otype T) void ^?{}(gcpointer(T)* this) {
+        ^?{}(&this->internal);
+}
+
+// forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
+//
+// forall(otype T) T *?(gcpointer(T) this);
+
+forall(otype T) T* get(gcpointer(T)* this) {
+        return (T*)this->internal.ptr;
+}
+//
+// //Logical operators
+// forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
+// forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);

src/examples/gc_no_raii/src/gcpointers.h

@@ -30 +30 @@
 forall(otype T) void ?{}(gcpointer(T)* this);
 forall(otype T) void ?{}(gcpointer(T)* this, void* address);
-forall(otype T) void ctor(gcpointer(T)* this, void* address);
 forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T)* other);
 forall(otype T) void ^?{}(gcpointer(T)* this);
@@ -37 +36 @@
 
 forall(otype T) T *?(gcpointer(T) this);
+forall(otype T) T* get(gcpointer(T)* this);
 
 //Logical operators

src/examples/gc_no_raii/src/internal/collector.c

@@ -8 +8 @@
 }
 #endif
+
+#include <fstream>
 
 #include "state.h"
@@ -36 +38 @@
 void* gc_allocate(size_t target_size)
 {
+        sout | "Allocating " | target_size | " bytes" | endl;
+
         size_t size = gc_compute_size(target_size + sizeof(gc_object_header));
+
+        sout | "Object header size: " | sizeof(gc_object_header) | " bytes" | endl;
+        sout | "Actual allocation size: " | size | " bytes" | endl;
 
         check(size < POOL_SIZE_BYTES);

src/examples/gc_no_raii/src/internal/state.h

@@ -9 +9 @@
 }
 #endif
+#include <fstream>
 #include <vector>
 
@@ -37 +38 @@
 static inline bool gc_needs_collect(gc_state* state)
 {
+        sout | "Used Space: " | state->used_space | " bytes" | endl;
         return state->used_space * 2 > state->total_space;
 }

src/examples/gc_no_raii/test/gctest.c

@@ -2 +2 @@
 
 #include "gc.h"
+#include "internal/collector.h"
 
 #warning default test
@@ -8 +9 @@
         sout | "Bonjour au monde!\n";
 
-        for(int i = 0; i < 1000000; i++) {
-                gcpointer(int) anInt;
-                gcmalloc(&anInt);
+        gcpointer(int) theInt;
+        gcmalloc(&theInt);
+
+        for(int i = 0; i < 10; i++) {
+                int a;
+                {
+                        gcpointer(int) anInt;
+                        gcmalloc(&anInt);
+                }
+                int p;
         }
+
+        gc_collect(gc_get_state());
+        gc_conditional_collect();
 }