Changeset 520145b

Timestamp:

Mar 6, 2018, 3:43:55 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

79d4186

Parents:

d893266a (diff), caa649b (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/SemanticError.h (modified) (1 diff)
• libcfa/concurrency/kernel (modified) (1 diff)
• libcfa/concurrency/kernel.c (modified) (13 diffs)
• libcfa/concurrency/kernel_private.h (modified) (1 diff)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/warnings/.expect/self-assignment.txt (modified) (1 diff)

src/Common/SemanticError.h

@@ -72 +72 @@
 }
 
-
-
-
 // Local Variables: //
 // tab-width: 4 //

src/libcfa/concurrency/kernel

@@ -79 +79 @@
 
 // Processor
+coroutine processorCtx_t {
+        struct processor * proc;
+};
+
 // Wrapper around kernel threads
 struct processor {
         // Main state
         // Coroutine ctx who does keeps the state of the processor
-        struct processorCtx_t * runner;
+        struct processorCtx_t runner;
 
         // Cluster from which to get threads

src/libcfa/concurrency/kernel.c

@@ -124 +124 @@
 //-----------------------------------------------------------------------------
 // Processor coroutine
+void ?{}(processorCtx_t & this) {}
 
 // Construct the processor context of the main processor
@@ -130 +131 @@
         this.__cor.starter = NULL;
         this.proc = proc;
-        proc->runner = &this;
 }
 
@@ -137 +137 @@
         (this.__cor){ info };
         this.proc = proc;
-        proc->runner = &this;
 }
 
@@ -150 +149 @@
         preemption_alarm = NULL;
         pending_preemption = false;
+        runner.proc = &this;
 
         start( &this );
@@ -161 +161 @@
         pending_preemption = false;
         kernel_thread = pthread_self();
-
-        this.runner = &runner;
+        runner.proc = &this;
+
         __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
         runner{ &this };
@@ -196 +196 @@
 void main(processorCtx_t & runner) {
         processor * this = runner.proc;
+        verify(this);
 
         __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
@@ -241 +242 @@
 void runThread(processor * this, thread_desc * dst) {
         assert(dst->curr_cor);
-        coroutine_desc * proc_cor = get_coroutine(*this->runner);
+        coroutine_desc * proc_cor = get_coroutine(this->runner);
         coroutine_desc * thrd_cor = dst->curr_cor;
 
@@ -256 +257 @@
 
 void returnToKernel() {
-        coroutine_desc * proc_cor = get_coroutine(*this_processor->runner);
+        coroutine_desc * proc_cor = get_coroutine(this_processor->runner);
         coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
         ThreadCtxSwitch(thrd_cor, proc_cor);
@@ -317 +318 @@
         machine_context_t ctx;
         info.context = &ctx;
-        processorCtx_t proc_cor_storage = { proc, &info };
-
-        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
+        (proc->runner){ proc, &info };
+
+        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base);
 
         //Set global state
-        this_coroutine = &proc->runner->__cor;
+        this_coroutine = get_coroutine(proc->runner);
         this_thread = NULL;
 
         //We now have a proper context from which to schedule threads
-        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
+        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx);
 
         // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
@@ -332 +333 @@
         // back to here. Instead directly call the main since we already are on the
         // appropriate stack.
-        proc_cor_storage.__cor.state = Active;
-        main( proc_cor_storage );
-        proc_cor_storage.__cor.state = Halted;
+        get_coroutine(proc->runner)->state = Active;
+        main( proc->runner );
+        get_coroutine(proc->runner)->state = Halted;
 
         // Main routine of the core returned, the core is now fully terminated
-        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
+        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
 
         return NULL;
@@ -352 +353 @@
 void kernel_first_resume(processor * this) {
         coroutine_desc * src = this_coroutine;
-        coroutine_desc * dst = get_coroutine(*this->runner);
+        coroutine_desc * dst = get_coroutine(this->runner);
 
         verify( !preemption_state.enabled );
 
         create_stack(&dst->stack, dst->stack.size);
-        CtxStart(this->runner, CtxInvokeCoroutine);
+        CtxStart(&this->runner, CtxInvokeCoroutine);
 
         verify( !preemption_state.enabled );
@@ -411 +412 @@
         verify( !preemption_state.enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
-        //TEMP hack to find a bug
-        if(this_processor != mainProcessor) {
-                if(ready_queue.head == mainThread) {
-                        unlock( ready_queue_lock );
-                        return NULL;
-                }
-        }
-
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
@@ -584 +577 @@
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(*mainProcessor->runner){};
+        ^(mainProcessor->runner){};
         ^(mainProcessor){};
 

src/libcfa/concurrency/kernel_private.h

@@ -52 +52 @@
 //-----------------------------------------------------------------------------
 // Processor
-coroutine processorCtx_t {
-        processor * proc;
-};
-
 void main(processorCtx_t *);
 void start(processor * this);

src/tests/Makefile.am

@@ -123 +123 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 
+# Warnings
 warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@}
-        echo > ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only

src/tests/Makefile.in

@@ -800 +800 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 
+# Warnings
 warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@}
-        echo > ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/tests/warnings/.expect/self-assignment.txt

@@ +1 @@
+warnings/self-assignment.c:29:1 warning: self assignment of expression: Cast of:
+  Variable Expression: j: signed int
+... to:
+  reference to signed int
+warnings/self-assignment.c:30:1 warning: self assignment of expression: Cast of:
+  Variable Expression: s: instance of struct S with body 1 
+... to:
+  reference to instance of struct S with body 1 
+warnings/self-assignment.c:31:1 warning: self assignment of expression: Cast of:
+  Member Expression, with field: 
+    i: signed int
+  ... from aggregate: 
+    Variable Expression: s: instance of struct S with body 1 
+... to:
+  reference to signed int
+warnings/self-assignment.c:32:1 warning: self assignment of expression: Cast of:
+  Member Expression, with field: 
+    i: signed int
+  ... from aggregate: 
+    Member Expression, with field: 
+      s: instance of struct S with body 1 
+    ... from aggregate: 
+      Variable Expression: t: instance of struct T with body 1 
+... to:
+  reference to signed int