[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET engine, compilers and tools (pnet) branch, master, updated. 707ac53acf965fc4a6fd8a2c4c1b85589f69c93c

[Klaus Treichel]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "DotGNU Portable.NET engine, compilers and tools (pnet)".

The branch, master has been updated
       via  707ac53acf965fc4a6fd8a2c4c1b85589f69c93c (commit)
      from  fca384f3377a54c11b6ca1c25e14b3e08b735360 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/pnet.git/commit/?id=707ac53acf965fc4a6fd8a2c4c1b85589f69c93c

commit 707ac53acf965fc4a6fd8a2c4c1b85589f69c93c
Author: Klaus Treichel <address@hidden>
Date:   Sat Dec 25 15:06:08 2010 +0100

    Move configuration of interpreter loop register variables from cvm.c to
    cvm_config.h and add an optional vmbreak barrier.

diff --git a/ChangeLog b/ChangeLog
index b59c5f9..9a8298f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,20 @@
+2010-12-25  Klaus Treichel  <address@hidden>
+
+       * engine/cvm_config.h: Move configuration of interpreter loop variables
+       from cvm.c to here.
+       Add optional definition of a vmbreak barrier if the unroller is used to
+       clobber registers that are used by the unrolled code but not saved.
+
+       * engine/cvm.c: Move configuration of interpreter loop variables to
+       cvm_config.h
+       (_ILCVMInterpreter): Prepend a CVM_ to the configurable register
+        variables.
+
+       * engine/mklabel.sh: Add the CVM_VMBREAK_BARRIER to the VMBREAK and
+       VMBREAKNOEND definitions for the direct threaded mode.
+
+       * engine/thread.c: Do some reformatting.
+
 2010-10-24  Klaus Treichel  <address@hidden>
 
        * engine/cvm_ptr.c: Fix cvmdoc generation for the
diff --git a/engine/cvm.c b/engine/cvm.c
index 3a79525..4fc1f63 100644
--- a/engine/cvm.c
+++ b/engine/cvm.c
@@ -41,23 +41,8 @@ extern       "C" {
  * are now in "cvm_config.h".
  */
 
-/*
- * Macros that can be used to bind important interpreter loop
- * variables to specific CPU registers for greater speed.
- * If we don't do this, then gcc generates VERY bad code for
- * the inner interpreter loop.  It just isn't smart enough to
- * figure out that "pc", "stacktop", and "frame" are the
- * best values to put into registers.
- */
 #if !defined(IL_NO_REGISTERS_USED)
 #if defined(CVM_X86) && defined(__GNUC__) && !defined(IL_NO_ASM)
-
-       #define REGISTER_ASM_X86 1
-
-    #define REGISTER_ASM_PC(x)              register x asm ("esi")
-    #define REGISTER_ASM_STACK(x)           register x asm ("edi")
-    #define REGISTER_ASM_FRAME(x)           register x asm ("ebx")
-
        /*
         * Memory copies on x86 use esi and edi, but we want them
         * for something else.  So we force the copy to go through
@@ -89,74 +74,26 @@ extern      "C" {
        {
                return ILMemCmp(dst, src, len);
        }
-#elif defined(CVM_X86_64) && defined(__GNUC__) && !defined(IL_NO_ASM)
-
-       #define REGISTER_ASM_X86_64 1
-
-       /* 16 registers - so we can avoid using esi, edi and ebx. */
-       #define REGISTER_ASM_PC(x)              register x asm("r12")
-       #define REGISTER_ASM_STACK(x)           register x asm("r14") 
-       #define REGISTER_ASM_FRAME(x)           register x asm("r15") 
-       #define IL_MEMCPY(dst,src,len)                  (ILMemCpy((dst), (src), 
(len)))
-       #define IL_MEMMOVE(dst,src,len)                 (ILMemMove((dst), 
(src), (len)))
-       #define IL_MEMZERO(dst,len)                             
(ILMemZero((dst), (len)))
-       #define IL_MEMSET(dst,ch,len)                   (ILMemSet((dst), (ch), 
(len)))
-       #define IL_MEMCMP(dst,src,len)                  (ILMemCmp((dst), (src), 
(len)))
-
-       #define X86_64_CGOTO(pc) do { __asm__ __volatile__ (\
-                                                               "jmpq *(%0)" \
-                                                               :: "r" (pc) ); \
-                                                               /* just to fool 
the compiler */ \
-                                                               goto ** ((void 
**)(pc)); } while(0)
-       /* VM_CGOTO_SWITCH segfaults with just a jmpq */
-       #define VM_CGOTO_PREFIXSWITCH(val) X86_64_CGOTO(pc)
-       #define VM_CGOTO_BREAK(val) X86_64_CGOTO(pc)
-       #define VM_CGOTO_BREAKNOEND(val) X86_64_CGOTO(pc)
-       
-#elif defined(CVM_ARM) && defined(__GNUC__) && !defined(IL_NO_ASM)
-
-       #define REGISTER_ASM_ARM 1
-
-    #define REGISTER_ASM_PC(x)              register x asm ("r4")
-    #define REGISTER_ASM_STACK(x)           register x asm ("r5")
-    #define REGISTER_ASM_FRAME(x)           register x asm ("r6")
-       #define IL_MEMCPY(dst,src,len)                  (ILMemCpy((dst), (src), 
(len)))
-       #define IL_MEMMOVE(dst,src,len)                 (ILMemMove((dst), 
(src), (len)))
-       #define IL_MEMZERO(dst,len)                             
(ILMemZero((dst), (len)))
-       #define IL_MEMSET(dst,ch,len)                   (ILMemSet((dst), (ch), 
(len)))
-       #define IL_MEMCMP(dst,src,len)                  (ILMemCmp((dst), (src), 
(len)))
-#elif defined(CVM_PPC) && defined(__GNUC__) && !defined(IL_NO_ASM)
-    #define REGISTER_ASM_PC(x)              register x asm ("r18")
-    #define REGISTER_ASM_STACK(x)           register x asm ("r19")
-    #define REGISTER_ASM_FRAME(x)           register x asm ("r20")
-    #define IL_MEMCPY(dst,src,len)          (ILMemCpy((dst), (src), (len)))
-    #define IL_MEMMOVE(dst,src,len)         (ILMemMove((dst), (src), (len)))
-    #define IL_MEMZERO(dst,len)             (ILMemZero((dst), (len)))
-    #define IL_MEMSET(dst,ch,len)           (ILMemSet((dst), (ch), (len)))
-    #define IL_MEMCMP(dst,src,len)          (ILMemCmp((dst), (src), (len)))
-#elif defined(CVM_IA64) && defined(__GNUC__) && !defined(IL_NO_ASM)
-    #define REGISTER_ASM_PC(x)              register x asm ("r4")
-    #define REGISTER_ASM_STACK(x)           register x asm ("r5")
-    #define REGISTER_ASM_FRAME(x)           register x asm ("r6")
-       #define IL_MEMCPY(dst,src,len)                  (ILMemCpy((dst), (src), 
(len)))
-       #define IL_MEMMOVE(dst,src,len)                 (ILMemMove((dst), 
(src), (len)))
-       #define IL_MEMZERO(dst,len)                             
(ILMemZero((dst), (len)))
-       #define IL_MEMSET(dst,ch,len)                   (ILMemSet((dst), (ch), 
(len)))
-       #define IL_MEMCMP(dst,src,len)                  (ILMemCmp((dst), (src), 
(len)))
-#else
-       #define IL_NO_REGISTERS_USED 1
 #endif
 #endif
 
-#if defined(IL_NO_REGISTERS_USED)
-       #define REGISTER_ASM_PC(x)              x
-       #define REGISTER_ASM_STACK(x)           x
-       #define REGISTER_ASM_FRAME(x)           x
-       #define IL_MEMCPY(dst,src,len)          (ILMemCpy((dst), (src), (len)))
-       #define IL_MEMMOVE(dst,src,len)         (ILMemMove((dst), (src), (len)))
-       #define IL_MEMZERO(dst,len)             (ILMemZero((dst), (len)))
-       #define IL_MEMSET(dst,ch,len)           (ILMemSet((dst), (ch), (len)))
-       #define IL_MEMCMP(dst,src,len)          (ILMemCmp((dst), (src), (len)))
+/*
+ * Define the memory macros if not defined.
+ */
+#ifndef IL_MEMCPY
+#define        IL_MEMCPY(dst,src,len)                  (ILMemCpy((dst), (src), 
(len)))
+#endif
+#ifndef IL_MEMMOVE
+#define        IL_MEMMOVE(dst,src,len)                 (ILMemMove((dst), 
(src), (len)))
+#endif
+#ifndef IL_MEMZERO
+#define        IL_MEMZERO(dst,len)                             
(ILMemZero((dst), (len)))
+#endif
+#ifndef IL_MEMSET
+#define        IL_MEMSET(dst,ch,len)                   (ILMemSet((dst), (ch), 
(len)))
+#endif
+#ifndef IL_MEMCMP
+#define        IL_MEMCMP(dst,src,len)                  (ILMemCmp((dst), (src), 
(len)))
 #endif
 
 /*
@@ -631,9 +568,9 @@ CVM_DEFINE_TABLES();
 
 int _ILCVMInterpreter(ILExecThread *thread)
 {
-       REGISTER_ASM_PC(unsigned char *IL_PC_VOLATILE pc);
-       REGISTER_ASM_STACK(CVMWord *IL_STACKTOP_VOLATILE stacktop);
-       REGISTER_ASM_FRAME(CVMWord *IL_FRAME_VOLATILE frame);
+       CVM_REGISTER_ASM_PC(unsigned char *IL_PC_VOLATILE pc);
+       CVM_REGISTER_ASM_STACK(CVMWord *IL_STACKTOP_VOLATILE stacktop);
+       CVM_REGISTER_ASM_FRAME(CVMWord *IL_FRAME_VOLATILE frame);
        int divResult;
        CVMWord  *IL_STACKMAX_VOLATILE stackmax;
        ILMethod *IL_METHOD_VOLATILE method;
diff --git a/engine/cvm_config.h b/engine/cvm_config.h
index 314a5fd..23fb826 100644
--- a/engine/cvm_config.h
+++ b/engine/cvm_config.h
@@ -243,6 +243,78 @@ extern int _ILCVMInsnCount[];
 #endif
 
 /*
+ * Macros that can be used to bind important interpreter loop
+ * variables to specific CPU registers for greater speed.
+ * If we don't do this, then gcc generates VERY bad code for
+ * the inner interpreter loop.  It just isn't smart enough to
+ * figure out that "pc", "stacktop", and "frame" are the
+ * best values to put into registers.
+ * If unrolling is done the macro CVM_VMBREAK_BARRIER should
+ * be defined to clobber all registers used by the unrolled
+ * code that are not saved to the stack before they are used.
+ * This makes sure that no values are stored in these registers
+ * between execution of two opcodes. This can easily happen
+ * with an optimizing compiler like gcc.
+ */
+#if !defined(IL_NO_REGISTERS_USED)
+#if defined(CVM_X86) && defined(__GNUC__) && !defined(IL_NO_ASM)
+
+       #define CVM_REGISTER_ASM_X86 1
+
+       #define CVM_REGISTER_ASM_PC(x)                  register x asm ("esi")
+       #define CVM_REGISTER_ASM_STACK(x)               register x asm ("edi")
+       #define CVM_REGISTER_ASM_FRAME(x)               register x asm ("ebx")
+#elif defined(CVM_X86_64) && defined(__GNUC__) && !defined(IL_NO_ASM)
+
+       #define CVM_REGISTER_ASM_X86_64 1
+
+       /* 16 registers - so we can avoid using esi, edi and ebx. */
+       #define CVM_REGISTER_ASM_PC(x)                  register x asm("r12")
+       #define CVM_REGISTER_ASM_STACK(x)               register x asm("r14") 
+       #define CVM_REGISTER_ASM_FRAME(x)               register x asm("r15") 
+#if defined(IL_CVM_DIRECT_UNROLLED)
+       #define CVM_VMBREAK_BARRIER()   \
+               __asm__ __volatile__ ("" : : : "rax", "rbx", "rcx", "rdx", 
"rsi", "rdi", "memory")
+#endif
+#elif defined(CVM_ARM) && defined(__GNUC__) && !defined(IL_NO_ASM)
+
+       #define CVM_REGISTER_ASM_ARM 1
+
+    #define CVM_REGISTER_ASM_PC(x)                     register x asm ("r4")
+    #define CVM_REGISTER_ASM_STACK(x)          register x asm ("r5")
+    #define CVM_REGISTER_ASM_FRAME(x)          register x asm ("r6")
+#elif defined(CVM_PPC) && defined(__GNUC__) && !defined(IL_NO_ASM)
+
+       #define CVM_REGISTER_ASM_PPC 1
+
+       #define CVM_REGISTER_ASM_PC(x)                  register x asm ("r18")
+       #define CVM_REGISTER_ASM_STACK(x)               register x asm ("r19")
+       #define CVM_REGISTER_ASM_FRAME(x)               register x asm ("r20")
+#elif defined(CVM_IA64) && defined(__GNUC__) && !defined(IL_NO_ASM)
+
+       #define CVM_REGISTER_ASM_IA64 1
+
+       #define CVM_REGISTER_ASM_PC(x)                  register x asm ("r4")
+       #define CVM_REGISTER_ASM_STACK(x)               register x asm ("r5")
+       #define CVM_REGISTER_ASM_FRAME(x)               register x asm ("r6")
+#else
+       #define IL_NO_REGISTERS_USED 1
+#endif
+#endif /* !defined(IL_NO_REGISTERS_USED) */
+
+#if defined(IL_NO_REGISTERS_USED)
+       #define CVM_REGISTER_ASM_PC(x)                  x
+       #define CVM_REGISTER_ASM_STACK(x)               x
+       #define CVM_REGISTER_ASM_FRAME(x)               x
+#endif
+
+#if defined(IL_CVM_DIRECT)
+#if !defined(CVM_VMBREAK_BARRIER)
+       #define CVM_BREAK_BARRIER()
+#endif
+#endif
+
+/*
  * The constructor offset value.
  */
 #ifdef IL_CVM_DIRECT
diff --git a/engine/mklabel.sh b/engine/mklabel.sh
index 2541a00..6434723 100755
--- a/engine/mklabel.sh
+++ b/engine/mklabel.sh
@@ -282,9 +282,11 @@ echo '#define VMPREFIXDEFAULT     _DEFAULT_PREFIX_label'
 echo '#endif /* !IL_VMCASE_BARRIER */'
 echo '#define VMBREAK(val)        \
             CVM_DUMP(); \
+            CVM_VMBREAK_BARRIER(); \
             VM_CGOTO_BREAK(val)'
 echo '#define VMBREAKNOEND        \
             CVM_DUMP(); \
+            CVM_VMBREAK_BARRIER(); \
             VM_CGOTO_BREAKNOEND(val)'
 echo '#define VMOUTERBREAK'
 echo '#else /* !IL_CVM_DIRECT */'
diff --git a/engine/thread.c b/engine/thread.c
index 1b2b89b..292d904 100644
--- a/engine/thread.c
+++ b/engine/thread.c
@@ -244,7 +244,7 @@ ILExecThread 
*ILThreadRegisterForManagedExecution(ILExecProcess *process, ILThre
                return execThread;
        }
 
-       /* Create a new engine-level thread */  
+       /* Create a new engine-level thread */
        if ((execThread = _ILExecThreadCreate(process, 0)) == 0)
        {
                return 0;

-----------------------------------------------------------------------

Summary of changes:
 ChangeLog           |   17 ++++++++
 engine/cvm.c        |  103 ++++++++++-----------------------------------------
 engine/cvm_config.h |   72 +++++++++++++++++++++++++++++++++++
 engine/mklabel.sh   |    2 +
 engine/thread.c     |    2 +-
 5 files changed, 112 insertions(+), 84 deletions(-)


hooks/post-receive
-- 
DotGNU Portable.NET engine, compilers and tools (pnet)