Changeset 76e8c55

Timestamp:

Aug 4, 2016, 12:30:01 PM (9 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:

064e3ff, cf37a8e

Parents:

8688ce1 (diff), bee4283 (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:

• GenPoly/Box.cc (modified) (9 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• examples/gc_no_raii/bug-repro/return_template.c (modified) (1 diff)
• examples/gc_no_raii/src/gc.h (modified) (1 diff)
• examples/gc_no_raii/src/gcpointers.c (modified) (1 diff)
• examples/gc_no_raii/src/gcpointers.h (modified) (2 diffs)
• examples/gc_no_raii/src/internal/memory_pool.h (modified) (1 diff)
• examples/gc_no_raii/src/internal/state.h (modified) (1 diff)
• examples/gc_no_raii/src/tools/worklist.h (modified) (1 diff)
• examples/gc_no_raii/test/badlll.c (modified) (2 diffs)
• examples/gc_no_raii/test/gctest.c (modified) (1 diff)

src/GenPoly/Box.cc ¶

@@ -619 +619 @@
                         return 0;
                 }
-                
+
                 /// Returns T if the given declaration is a function with parameters (T*, T) for some TypeInstType T, NULL otherwise
                 TypeInstType *isTypeInstPtrValFn( DeclarationWithType *decl ) {
@@ -637 +637 @@
                         return 0;
                 }
-                
+
                 /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
                 TypeInstType *isTypeInstAssignment( DeclarationWithType *decl ) {
@@ -677 +677 @@
                         return 0;
                 }
-                
+
                 /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified,
                 /// NULL otherwise
@@ -772 +772 @@
                                 copyOps.beginScope();
                                 dtorOps.beginScope();
-                                
+
                                 DeclarationWithType *oldRetval = retval;
                                 bool oldUseRetval = useRetval;
@@ -1471 +1471 @@
                 VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) {
                         // line below cloned from FixFunction.cc
+                        // xxx - functionObj is never added to a list of declarations...
                         ObjectDecl *functionObj = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
                                                                   new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
                         functionObj->set_mangleName( functionDecl->get_mangleName() );
+                        functionObj->set_scopeLevel( functionDecl->get_scopeLevel() );
                         return new VariableExpr( functionObj );
                 }
@@ -1492 +1494 @@
                                         = ParamEntry( assertOp->get_uniqueId(), assertOp->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertOp ) );
                 }
-                
+
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
@@ -1554 +1556 @@
                                                 DeclarationWithType *assertDtor = findOpForType( formalType, dtorOps, scopedDtorOps );
                                                 if ( ! assertDtor ) throw SemanticError( "No destructor found for ", formalType );
-                                                
+
                                                 // add inferred parameters for otype operators to assignment expression
                                                 // NOTE: Code here assumes that first four assertions are assign op, ctor, copy ctor, dtor, in that order
@@ -1568 +1570 @@
                                                 ++actualIt;
                                                 addAssertionFor( assignExpr, *actualIt, assertDtor );
-                                                
-                                                //DeclarationWithType *actualDecl = asserts.front();
-                                                //assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
-                                                //      = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
+
                                         }
                                 }
@@ -2181 +2180 @@
                 bool PolyGenericCalculator::findGeneric( Type *ty ) {
                         ty = replaceTypeInst( ty, env );
-                        
+
                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
                                 if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {

src/SymTab/Validate.cc ¶

@@ -541 +541 @@
                 if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
                         return new StructDecl( aggDecl->get_name() );
-//                      return aggDecl->get_baseStruct();
                 } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
                         return new UnionDecl( aggDecl->get_name() );
+                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( tyDecl->get_base() ) ) {
+                        return new EnumDecl( enumDecl->get_name() );
                 } else {
                         return ret;

src/examples/gc_no_raii/bug-repro/return_template.c ¶

@@ -5 +5 @@
 };
 
+forall(otype T) void ?{}(wrap(T)* this);
+forall(otype T) void ?{}(wrap(T)* this, wrap(T)* rhs);
+forall(otype T) void ^?{}(wrap(T)* this);
+forall(otype T) void ?=?(wrap(T)* this, wrap(T)* rhs);
+
 forall(otype T)
-static inline wrap(T) test()
+wrap(T) test()
 {
         wrap(T) tester;

src/examples/gc_no_raii/src/gc.h ¶

@@ -7 +7 @@
 static inline gcpointer(T) gcmalloc()
 {
-    gcpointer(T) test;
-    // ctor(&test, gc_allocate(sizeof(T)));
-    // gc_conditional_collect();
-    return test;
+    gcpointer(T) ptr;
+    void* address = gc_allocate(sizeof(T));
+    (&ptr){ address };
+    ctor(&ptr, address);
+    gc_conditional_collect();
+    return ptr;
 }

src/examples/gc_no_raii/src/gcpointers.c ¶

@@ -1 +1 @@
 #include "gcpointers.h"
 
-#include "gc.h"
+// #include "gc.h"
 #include "internal/collector.h"
 #include "internal/object_header.h"

src/examples/gc_no_raii/src/gcpointers.h ¶

@@ -10 +10 @@
 };
 
-void gcpointer_ctor(gcpointer_t* this);
-void gcpointer_ctor(gcpointer_t* this, void* address);
-void gcpointer_ctor(gcpointer_t* this, gcpointer_t* other);
-void gcpointer_dtor(gcpointer_t* this);
-gcpointer_t* gcpointer_assign(gcpointer_t* this, gcpointer_t* rhs);
+void ?{}(gcpointer_t* this);
+void ?{}(gcpointer_t* this, void* address);
+void ?{}(gcpointer_t* this, gcpointer_t other);
+void ^?{}(gcpointer_t* this);
+gcpointer_t* ?=?(gcpointer_t this, gcpointer_t rhs);
 
 //Logical operators
@@ -27 +27 @@
 };
 
-forall(otype T)
-static inline void ctor(gcpointer(T)* this)
-{
-        gcpointer_ctor(&this->internal);
-}
+//
+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);
+forall(otype T) gcpointer(T) ?=?(gcpointer(T) this, gcpointer(T) rhs);
 
-// forall(otype T)
-// static inline void ctor(gcpointer(T)* this, int null)
-// {
-//      gcpointer_ctor(&this->internal, NULL);
-// }
 
-forall(otype T)
-static inline void ctor(gcpointer(T)* this, void* address)
-{
-        gcpointer_ctor(&this->internal, address);
-}
-
-forall(otype T)
-static inline void ctor(gcpointer(T)* this, gcpointer(T)* other)
-{
-        gcpointer_ctor(&this->internal, other);
-}
-
-forall(otype T)
-static inline void dtor(gcpointer(T)* this)
-{
-        gcpointer_dtor(&this->internal);
-}
-
-forall(otype T)
-static inline gcpointer(T)* ?=?(gcpointer(T)* this, gcpointer(T)* rhs)
-{
-        gcpointer_assign(&this->internal, &rhs->internal);
-        return this;
-}
-
-forall(otype T)
-static inline T *?(gcpointer(T) this)
-{
-        return *(T*)this.internal.ptr;
-}
+forall(otype T) T *?(gcpointer(T) this);
 
 //Logical operators
-forall(otype T)
-static inline int ?!=?(gcpointer(T) this, gcpointer(T) rhs)
-{
-        return this.internal.ptr != rhs.internal.ptr;
-}
-
-forall(otype T)
-static inline int ?==?(gcpointer(T) this, gcpointer(T) rhs)
-{
-        return !(this == rhs);
-}
-
-forall(otype T)
-extern struct gcpointer(T) 0;
+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/internal/memory_pool.h ¶

@@ -3 +3 @@
 extern "C" {
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 }

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

@@ -1 +1 @@
 #pragma once
 
+#ifdef __cforall
+extern "C" {
+#endif
 #include <stddef.h>
 #include <stdint.h>
+#ifdef __cforall
+}
+#endif
+#include <vector>
 
 #include "tools.h"
-#include "vector.h"
 
 typedef vector(struct gc_memory_pool*, heap_allocator(struct gc_memory_pool*)) pools_table_t;

src/examples/gc_no_raii/src/tools/worklist.h ¶

@@ -10 +10 @@
 #endif
 
-#include "vector.h"
+#include <vector>
 
 typedef vector(intptr_t*, heap_allocator(intptr_t*)) worklist_t;

src/examples/gc_no_raii/test/badlll.c ¶

@@ -7 +7 @@
 };
 
+void ?{}(List_t* this);
+List_t* ?=?(List_t* this, List_t* rhs);
+
 typedef gcpointer(List_t) LLL;
 
 #define MAX (1024 * 1024)
 
-LLL buildLLL(int sz)
+// LLL buildLLL(int sz)
+void bla()
 {
         int i;
-        LLL ll0, lll, llc;
-
-        ll0 = gcmalloc();
-        ll0->val = 0;
-        lll = ll0;
-
-        for (i = 1; i < sz; i++)
-        {
-                llc = gcmalloc();
-                llc->val = i;
-                lll->next = llc;
-                lll = llc;
-        }
-
-        return ll0;
+        // LLL ll0;//, lll, llc;
+//
+//      ll0 = gcmalloc();
+//      ll0->val = 0;
+//      lll = ll0;
+//
+//      for (i = 1; i < sz; i++)
+//      {
+//              llc = gcmalloc();
+//              llc->val = i;
+//              lll->next = llc;
+//              lll = llc;
+//      }
+//
+        // return ll0;
 }
-
-void testLLL(LLL lll)
-{
-        unsigned char *counted;
-
-        counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
-        while (lll)
-        {
-                counted[lll->val]++;
-                if (counted[lll->val] > 1)
-                {
-                        fprintf(stderr, "ERROR! Encountered %d twice!\n", lll->val);
-                        exit(1);
-                }
-                lll = lll->next;
-        }
-
-        return;
-}
+//
+// void testLLL(LLL lll)
+// {
+//      unsigned char *counted;
+//
+//      counted = (unsigned char *) calloc(MAX, sizeof(unsigned char));
+//      while (lll)
+//      {
+//              counted[lll->val]++;
+//              if (counted[lll->val] > 1)
+//              {
+//                      fprintf(stderr, "ERROR! Encountered %d twice!\n", lll->val);
+//                      exit(1);
+//              }
+//              lll = lll->next;
+//      }
+//
+//      return;
+// }
 
 int main(void)
@@ -54 +58 @@
         LLL mylll;
 
-        mylll = buildLLL(MAX);
-
-        testLLL(mylll);
+        // mylll = buildLLL(MAX);
+        //
+        // testLLL(mylll);
 
         return 0;

src/examples/gc_no_raii/test/gctest.c ¶

@@ -7 +7 @@
 int main() {
         sout | "Bonjour au monde!\n";
+
+        gcpointer(int) anInt = gcmalloc();
 }