unbreak win64 COPY_STACK

Make.inc

@@ -679,7 +679,7 @@ endif
 ifeq ($(OS), WINNT)
 ifneq ($(USEMSVC), 1)
 OSLIBS += -Wl,--export-all-symbols -Wl,--version-script=$(JULIAHOME)/src/julia.expmap \
-	$(NO_WHOLE_ARCHIVE) -lpsapi -lkernel32 -lws2_32 -liphlpapi -lwinmm -ldbghelp -lssp
+	$(NO_WHOLE_ARCHIVE) -lpsapi -lkernel32 -lws2_32 -liphlpapi -lwinmm -ldbghelp
 JLDFLAGS = -Wl,--stack,8388608
 ifeq ($(ARCH),i686)
 JLDFLAGS += -Wl,--large-address-aware

doc/manual/embedding.rst

@@ -19,8 +19,8 @@ We start with a simple C program that initializes Julia and calls some Julia cod
   int main(int argc, char *argv[])
   {
       /* optional: randomize the stack guard */
-      char a, b, c;
-      SET_STACK_CHK_GUARD(a,b,c);
+      char a=255, b='\n', c=0;
+      SWAP_STACK_CHK_GUARD(a,b,c);
 
       /* required: setup the julia context */
       jl_init(NULL);
@@ -36,7 +36,7 @@ We start with a simple C program that initializes Julia and calls some Julia cod
       jl_atexit_hook();
 
       /* if the stack guard is set: reset the stack guard */
-      CLR_STACK_CHK_GUARD(a,b,c);
+      SWAP_STACK_CHK_GUARD(a,b,c);
       return 0;
   }
 

examples/Makefile

@@ -1,9 +1,6 @@
 JULIAHOME = $(abspath ..)
 include $(JULIAHOME)/Make.inc
 
-override CFLAGS += $(JCFLAGS)
-override CXXFLAGS += $(JCXXFLAGS)
-
 FLAGS = -Wall -Wno-strict-aliasing -fno-omit-frame-pointer \
 	-I$(JULIAHOME)/src -I$(JULIAHOME)/src/support -I$(build_includedir) $(CFLAGS)
 

examples/embedding.c

@@ -9,8 +9,8 @@ double my_c_sqrt(double x)
 
 int main()
 {
-    char a, b, c;
-    SET_STACK_CHK_GUARD(a,b,c);
+    char a=255, b='\n', c=0;
+    SWAP_STACK_CHK_GUARD(a,b,c);
     jl_init(NULL);
 
     {
@@ -52,14 +52,15 @@ int main()
 
         double* xData = jl_array_data(x);
 
-        for(size_t i=0; i<jl_array_len(x); i++)
+        size_t i;
+        for(i=0; i<jl_array_len(x); i++)
             xData[i] = i;
 
         jl_function_t *func  = jl_get_function(jl_base_module, "reverse!");
         jl_call1(func, (jl_value_t*) x);
 
         printf("x = [");
-        for(size_t i=0; i<jl_array_len(x); i++)
+        for(i=0; i<jl_array_len(x); i++)
             printf("%e ", xData[i]);
         printf("]\n");
 
@@ -96,6 +97,6 @@ int main()
     }
 
     jl_atexit_hook();
-    CLR_STACK_CHK_GUARD(a,b,c);
+    SWAP_STACK_CHK_GUARD(a,b,c);
     return 0;
 }

src/codegen.cpp

@@ -121,8 +121,7 @@ extern "C" {
 
 #include "builtin_proto.h"
 
-DLLEXPORT void *__stack_chk_guard = NULL;
-
+extern void *__stack_chk_guard;
 #if defined(_OS_WINDOWS_) && !defined(_COMPILER_MINGW_)
 void __stack_chk_fail()
 #else
@@ -4359,7 +4358,7 @@ static void init_julia_llvm_env(Module *m)
         Function::Create(FunctionType::get(T_void, false),
                          Function::ExternalLinkage,
                          "__stack_chk_fail", m);
-    //jl__stack_chk_fail->setDoesNotReturn();
+    jl__stack_chk_fail->setDoesNotReturn();
     add_named_global(jl__stack_chk_fail, (void*)&__stack_chk_fail);
 
     jltrue_var = global_to_llvm("jl_true", (void*)&jl_true, m);

src/init.c

@@ -104,6 +104,10 @@ jl_compileropts_t jl_compileropts = { NULL, // julia_home
 int jl_boot_file_loaded = 0;
 int exit_on_sigint = 0;
 
+void *__stack_chk_guard = NULL;
+DLLEXPORT unsigned char *jl_stack_chk_guard =
+    (unsigned char *)&__stack_chk_guard;
+
 char *jl_stack_lo;
 char *jl_stack_hi;
 size_t jl_page_size;

src/julia.h

@@ -1347,24 +1347,21 @@ extern DLLEXPORT jl_compileropts_t jl_compileropts;
 #define JL_COMPILEROPT_DUMPBITCODE_ON 1
 #define JL_COMPILEROPT_DUMPBITCODE_OFF 2
 
-DLLEXPORT extern void *__stack_chk_guard;
-#define SET_STACK_CHK_GUARD(a,b,c) do {                         \
-        unsigned char *p = (unsigned char *)&__stack_chk_guard; \
-        a = p[sizeof(__stack_chk_guard)-1];                     \
-        b = p[sizeof(__stack_chk_guard)-2];                     \
-        c = p[0];                                               \
-        /* If you have the ability to generate random numbers
-         * in your kernel then they should be used here */      \
-        p[sizeof(__stack_chk_guard)-1] = 255;                   \
-        p[sizeof(__stack_chk_guard)-2] = '\n';                  \
-        p[0] = 0;                                               \
-    } while (0)
-
-#define CLR_STACK_CHK_GUARD(a,b,c) do {                         \
-        unsigned char *p = (unsigned char *)&__stack_chk_guard; \
-        p[sizeof(__stack_chk_guard)-1] = a;                     \
-        p[sizeof(__stack_chk_guard)-2] = b;                     \
-        p[0] = c;                                               \
+/* If you have the ability to generate random numbers
+* in your kernel then they should be used here */
+DLLEXPORT extern unsigned char *jl_stack_chk_guard;
+#define SWAP_STACK_CHK_GUARD(a,b,c) do {                        \
+        a ^= jl_stack_chk_guard[sizeof(void*)-1];               \
+        jl_stack_chk_guard[sizeof(void*)-1] ^= a;               \
+        a ^= jl_stack_chk_guard[sizeof(void*)-1];               \
+                                                                \
+        b ^= jl_stack_chk_guard[sizeof(void*)-2];               \
+        jl_stack_chk_guard[sizeof(void*)-2] ^= b;               \
+        b ^= jl_stack_chk_guard[sizeof(void*)-2];               \
+                                                                \
+        c ^= jl_stack_chk_guard[0];                             \
+        jl_stack_chk_guard[0] ^= c;                             \
+        c ^= jl_stack_chk_guard[0];                             \
     } while (0)
 
 #ifdef __cplusplus

src/task.c

@@ -341,20 +341,24 @@ static void ctx_switch(jl_task_t *t, jl_jmp_buf *where)
             restore_stack(t, where, NULL);
         } else {
 #ifdef ASM_COPY_STACKS
+            void *stackbase = jl_stackbase - 0x10;
 #ifdef _CPU_X86_64_
+#ifdef _OS_WINDOWS_
+            stackbase -= 0x20;
+#endif
             asm(" movq %0, %%rsp;\n"
                 " xorq %%rbp, %%rbp;\n"
                 " push %%rbp;\n" // instead of RSP
                 " jmp %P1;\n" // call stack_task with fake stack frame
                 " ud2"
-                : : "r"(jl_stackbase-0x10), "i"(start_task) : "memory" );
+                : : "r"(stackbase), "i"(start_task) : "memory" );
 #elif defined(_CPU_X86_)
             asm(" movl %0, %%esp;\n"
                 " xorl %%ebp, %%ebp;\n"
                 " push %%ebp;\n" // instead of ESP
                 " jmp %P1;\n" // call stack_task with fake stack frame
                 " ud2"
-                : : "r"(jl_stackbase-0x10), "i"(start_task) : "memory" );
+                : : "r"(stackbase), "i"(start_task) : "memory" );
 #else
 #error ASM_COPY_STACKS not supported on this cpu architecture
 #endif

ui/repl.c

@@ -330,8 +330,8 @@ int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
         argv[i] = (wchar_t*)arg;
     }
 #endif
-    char a,b,c;
-    SET_STACK_CHK_GUARD(a,b,c);
+    char a=255,b='\n',c=0;
+    SWAP_STACK_CHK_GUARD(a,b,c);
     libsupport_init();
     parse_opts(&argc, (char***)&argv);
     if (lisp_prompt) {
@@ -342,7 +342,7 @@ int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
     int ret = true_main(argc, (char**)argv);
     jl_atexit_hook();
     julia_save();
-    CLR_STACK_CHK_GUARD(a,b,c);
+    SWAP_STACK_CHK_GUARD(a,b,c);
     return ret;
 }