ext: Include SystemC 2.3.1 into gem5

In the past it happened several times that some changes in gem5 broke the
SystemC coupling. Recently Accelera has changed the licence for SystemC
from their own licence to Apache2.0, which is compatible with gem5.
However, SystemC usually relies on the Boost library, but I was able to
exchange the boost calls by c++11 alternatives. The recent SystemC version
is placed into /ext and is integrated into gem5's build system. The goal is
to integrate some SystemC tests for the CI in some following patches.

Change-Id: I4b66ec806b5e3cffc1d7c85d3735ff4fa5b31fd0
Reviewed-on: https://gem5-review.googlesource.com/2240
Reviewed-by: Andreas Sandberg <andreas.sandberg@arm.com>
Maintainer: Andreas Sandberg <andreas.sandberg@arm.com>

1 files changed, 164 insertions, 0 deletions

diff --git a/ext/systemc/src/sysc/qt/md/ksr1.h b/ext/systemc/src/sysc/qt/md/ksr1.h
new file mode 100644
index 000000000..b3877505d
--- /dev/null
+++ b/ext/systemc/src/sysc/qt/md/ksr1.h
@@ -0,0 +1,164 @@
+/*
+ * QuickThreads -- Threads-building toolkit.
+ * Copyright (c) 1993 by David Keppel
+ *
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice and this notice
+ * appear in all copies.  This software is provided as a
+ * proof-of-concept and for demonstration purposes; there is no
+ * representation about the suitability of this software for any
+ * purpose.
+ */
+
+#ifndef QUICKTHREADS_KSR1_H
+#define QUICKTHREADS_KSR1_H
+
+/* 
+   Stack layout:
+
+   Registers are saved in strictly low to high order, FPU regs first 
+   (only if qt_block is called), CEU regs second, IPU regs next, with no
+   padding between the groups.
+
+   Callee-save:  f16..f63; c15..c30; i12..i30.
+   Args passed in i2..i5.
+
+   Note: c31 is a private data pointer.  It is not changed on thread
+   swaps with the assumption that it represents per-processor rather
+   than per-thread state.
+
+   Note: i31 is an instruction count register that is updated by the
+   context switch routines.  Like c31, it is not changed on context
+   switches.
+
+   This is what we want on startup:
+
+
+   +------		<-- BOS: Bottom of stack (grows down)
+   | 80 (128 - 48) bytes of padding to a 128-byte boundary
+   +---
+   | only
+   | userf
+   | t
+   | u
+   | qt_start$TXT
+   | (empty)     	<-- qt.sp
+   +------		<-- (BOS - 128)
+
+   This is why we want this on startup:
+   
+   A thread begins running when the restore procedure switches thread stacks
+   and pops a return address off of the top of the new stack (see below
+   for the reason why we explicitly store qt_start$TXT).  The
+   block procedure pushes two jump addresses on a thread's stack before
+   it switches stacks.  The first is the return address for the block
+   procedure, and the second is a restore address.  The return address
+   is used to jump back to the thread that has been switched to;  the
+   restore address is a jump within the block code to restore the registers.
+   Normally, this is just a jump to the next address.  However, on thread
+   startup, this is a jump to qt_start$TXT.  (The block procedure stores
+   the restore address at an offset of 8 bytes from the top of the stack,
+   which is also the offset at which qt_start$TXT is stored on the stacks
+   of new threads.  Hence, when the block procedure switches to a new
+   thread stack, it will initially jump to qt_start$TXT; thereafter,
+   it jumps to the restore code.)
+
+   qt_start$TXT, after it has read the initial data on the new thread's
+   stack and placed it in registers, pops the initial stack frame
+   and gives the thread the entire stack to use for execution.
+
+   The KSR runtime system has an unusual treatment of pointers to
+   functions.  From C, taking the `name' of a function yields a
+   pointer to a _constant block_ and *not* the address of the
+   function.  The zero'th entry in the constant block is a pointer to
+   the function.
+
+   We have to be careful: the restore procedure expects a return
+   address on the top of the stack (pointed to by qt.sp).  This is not
+   a problem when restoring a thread that has run before, since the
+   block routine would have stored the return address on top of the
+   stack.  However, when ``faking up'' a thread start (bootstrapping a
+   thread stack frame), the top of the stack needs to contain a
+   pointer to the code that will start the thread running.
+
+   The pointer to the startup code is *not* `qt_start'.  It is the
+   word *pointed to* by `qt_start'.  Thus, we dereference `qt_start',
+   see QUICKTHREADS_ARGS_MD below.
+
+   On varargs startup (still unimplemented):
+
+   | padding to 128 byte boundary
+   | varargs		<-- padded to a 128-byte-boundary
+   +---
+   | caller's frame, 16 bytes
+   | 80 bytes of padding (frame padded to a 128-byte boundary)
+   +---
+   | cleanup
+   | vuserf
+   | startup
+   | t
+   +---
+   | qt_start		<-- qt.sp
+   +---
+
+   Of a suspended thread:
+
+   +---
+   | caller's frame, 16 bytes
+   | fpu registers 47 regs * 8 bytes/reg 376 bytes
+   | ceu registers 16 regs * 8 bytes/reg 128 bytes
+   | ipu registers 19 regs * 8 bytes/reg 152 bytes
+   |  :
+   | 80 bytes of padding
+   |  :
+   | qt_restore		<-- qt.sp
+   +---
+
+   */
+
+
+#define QUICKTHREADS_STKALIGN	128
+#define QUICKTHREADS_GROW_DOWN
+typedef unsigned long qt_word_t;
+
+#define QUICKTHREADS_STKBASE	QUICKTHREADS_STKALIGN
+#define QUICKTHREADS_VSTKBASE	QUICKTHREADS_STKBASE
+
+extern void qt_start(void);
+/*
+ * See the discussion above for what indexing into a procedure ptr 
+ * does for us (it's lovely, though, isn't it?).
+ *
+ * This assumes that the address of a procedure's code is the
+ * first word in a procedure's constant block.  That's how the manual
+ * says it will be arranged.
+ */
+#define QUICKTHREADS_ARGS_MD(sp)	(QUICKTHREADS_SPUT (sp, 1, ((qt_word_t *)qt_start)[0]))
+
+/* 
+ * The *index* (positive offset) of where to put each value.
+ * See the picture of the stack above that explains the offsets.
+ */
+#define QUICKTHREADS_ONLY_INDEX	(5)
+#define QUICKTHREADS_USER_INDEX	(4)
+#define QUICKTHREADS_ARGT_INDEX	(3)
+#define QUICKTHREADS_ARGU_INDEX	(2)
+
+#define QUICKTHREADS_VARGS_DEFAULT
+#define QUICKTHREADS_VARGS(sp, nb, vargs, pt, startup, vuserf, cleanup) \
+      (qt_vargs (sp, nbytes, &vargs, pt, startup, vuserf, cleanup))
+
+
+#define QUICKTHREADS_VARGS_MD0(sp, vabytes) \
+  ((qt_t *)(((char *)(sp)) - 4*8 - QUICKTHREADS_STKROUNDUP(vabytes)))
+
+extern void qt_vstart(void);
+#define QUICKTHREADS_VARGS_MD1(sp)	(QUICKTHREADS_SPUT (sp, 0, ((qt_word_t *)qt_vstart)[0]))
+
+#define QUICKTHREADS_VCLEANUP_INDEX	(4)
+#define QUICKTHREADS_VUSERF_INDEX		(3)
+#define QUICKTHREADS_VSTARTUP_INDEX	(2)
+#define QUICKTHREADS_VARGT_INDEX		(1)
+
+#endif /* def QUICKTHREADS_KSR1_H */