Merge branch 'rickard/pcre-8.40'

OTP-14331

* rickard/pcre-8.40:
  Update documentation
  Update README.pcre_update.md
  Stack guard for PCRE
  Adjust for incompatibility between PCRE 8.40 and perl 5.22.1
  Generate re replacement and split tests with perl vsn 5.22.1
  Fix re_SUITE:pcre_compile_workspace_overflow/1
  Skip line with lockout of modifiers in PCRE tests
  Update tests for PCRE version 8.40
  Update PCRE to version 8.40

Conflicts:
	erts/emulator/beam/beam_debug.c

7 files changed, 196 insertions, 15 deletions

diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index 8326d348af..88b223cf49 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -1118,3 +1118,48 @@ ms_wait(Process *c_p, Eterm etimeout, int busy)
 }
 
 #endif /* ERTS_DIRTY_SCHEDULERS */
+
+#ifdef ERTS_SMP
+#  define ERTS_STACK_LIMIT ((char *) ethr_get_stacklimit())
+#else
+#  define ERTS_STACK_LIMIT ((char *) erts_scheduler_stack_limit)
+#endif
+
+/*
+ * The below functions is for testing of the stack
+ * limit functionality. They are intentionally
+ * written body recursive in order to prevent
+ * last call optimization...
+ */
+
+UWord
+erts_check_stack_recursion_downwards(char *start_c)
+{
+    char *limit = ERTS_STACK_LIMIT;
+    char c;
+    UWord res;
+    if (erts_check_below_limit(&c, limit + 1024))
+        return (char *) erts_ptr_id(start_c) - (char *) erts_ptr_id(&c);
+    res = erts_check_stack_recursion_downwards(start_c);
+    erts_ptr_id(&c);
+    return res;
+}
+
+UWord
+erts_check_stack_recursion_upwards(char *start_c)
+{
+    char *limit = ERTS_STACK_LIMIT;
+    char c;
+    UWord res;
+    if (erts_check_above_limit(&c, limit - 1024))
+        return (char *) erts_ptr_id(&c) - (char *) erts_ptr_id(start_c);
+    res = erts_check_stack_recursion_upwards(start_c);
+    erts_ptr_id(&c);
+    return res;
+}
+
+int
+erts_is_above_stack_limit(char *ptr)
+{
+    return (char *) ptr > ERTS_STACK_LIMIT;
+}
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index 025f99330a..3a8687dc59 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -3743,6 +3743,21 @@ BIF_RETTYPE erts_debug_get_internal_state_1(BIF_ALIST_1)
 		BIF_RET(erts_sint64_to_big(value, &hp));
 	    }
 	}
+        else if (ERTS_IS_ATOM_STR("stack_check", BIF_ARG_1)) {
+            UWord size;
+            char c;
+            if (erts_is_above_stack_limit(&c))
+                size = erts_check_stack_recursion_downwards(&c);
+            else
+                size = erts_check_stack_recursion_upwards(&c);
+	    if (IS_SSMALL(size))
+		BIF_RET(make_small(size));
+	    else {
+		Uint hsz = BIG_UWORD_HEAP_SIZE(size);
+		Eterm *hp = HAlloc(BIF_P, hsz);
+		BIF_RET(uword_to_big(size, hp));
+	    }
+        }
     }
     else if (is_tuple(BIF_ARG_1)) {
 	Eterm* tp = tuple_val(BIF_ARG_1);
diff --git a/erts/emulator/beam/erl_bif_re.c b/erts/emulator/beam/erl_bif_re.c
index a66b05c6ff..925d99e0de 100644
--- a/erts/emulator/beam/erl_bif_re.c
+++ b/erts/emulator/beam/erl_bif_re.c
@@ -64,12 +64,47 @@ static void erts_erts_pcre_stack_free(void *ptr) {
     erts_free(ERTS_ALC_T_RE_STACK,ptr);
 }
 
+#define ERTS_PCRE_STACK_MARGIN (10*1024)
+
+#ifdef ERTS_SMP
+#  define ERTS_STACK_LIMIT ((char *) ethr_get_stacklimit())
+#else
+#  define ERTS_STACK_LIMIT ((char *) erts_scheduler_stack_limit)
+#endif
+
+static int
+stack_guard_downwards(void)
+{
+    char *limit = ERTS_STACK_LIMIT;
+    char c;
+
+    ASSERT(limit);
+
+    return erts_check_below_limit(&c, limit + ERTS_PCRE_STACK_MARGIN);
+}
+
+static int
+stack_guard_upwards(void)
+{
+    char *limit = ERTS_STACK_LIMIT;
+    char c;
+
+    ASSERT(limit);
+
+    return erts_check_above_limit(&c, limit - ERTS_PCRE_STACK_MARGIN);
+}
+
 void erts_init_bif_re(void)
 {
+    char c;
     erts_pcre_malloc = &erts_erts_pcre_malloc;
     erts_pcre_free = &erts_erts_pcre_free;
     erts_pcre_stack_malloc = &erts_erts_pcre_stack_malloc;
     erts_pcre_stack_free = &erts_erts_pcre_stack_free;
+    if ((char *) erts_ptr_id(&c) > ERTS_STACK_LIMIT)
+        erts_pcre_stack_guard = stack_guard_downwards;
+    else
+        erts_pcre_stack_guard = stack_guard_upwards;
     default_table = NULL; /* ISO8859-1 default, forced into pcre */
     max_loop_limit = CONTEXT_REDS * LOOP_FACTOR;
 
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 61477af316..56c0f19230 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -61,6 +61,9 @@
 
 #define ERTS_DEFAULT_NO_ASYNC_THREADS	10
 
+#define ERTS_DEFAULT_SCHED_STACK_SIZE   256
+#define ERTS_MIN_SCHED_STACK_SIZE       20
+
 /*
  * The variables below (prefixed with etp_) are for erts/etc/unix/etp-commands
  * only. Do not remove even though they aren't used elsewhere in the emulator!
@@ -125,6 +128,8 @@ const Eterm etp_hole_marker = ERTS_HOLE_MARKER;
 const Eterm etp_hole_marker = 0;
 #endif
 
+static int modified_sched_thread_suggested_stack_size = 0;
+
 /*
  * Note about VxWorks: All variables must be initialized by executable code,
  * not by an initializer. Otherwise a new instance of the emulator will
@@ -1237,24 +1242,38 @@ early_init(int *argc, char **argv) /*
 }
 
 #ifndef ERTS_SMP
+
+void *erts_scheduler_stack_limit;
+
+
 static void set_main_stack_size(void)
 {
-    if (erts_sched_thread_suggested_stack_size > 0) {
+    char c;
+    UWord stacksize;
 # if HAVE_DECL_GETRLIMIT && HAVE_DECL_SETRLIMIT && HAVE_DECL_RLIMIT_STACK
-	struct rlimit rl;
-	int bytes = erts_sched_thread_suggested_stack_size * sizeof(Uint) * 1024;
-	if (getrlimit(RLIMIT_STACK, &rl) != 0 ||
-	    (rl.rlim_cur = bytes, setrlimit(RLIMIT_STACK, &rl) != 0)) {
-	    erts_fprintf(stderr, "failed to set stack size for scheduler "
-				 "thread to %d bytes\n", bytes);
-	    erts_usage();
-	}	    
+    struct rlimit rl;
+    int bytes;
+    stacksize = erts_sched_thread_suggested_stack_size * sizeof(Uint) * 1024;
+    /* Add some extra pages... neede by some systems... */
+    bytes = (int) stacksize + 3*erts_sys_get_page_size();
+    if (getrlimit(RLIMIT_STACK, &rl) != 0 ||
+        (rl.rlim_cur = bytes, setrlimit(RLIMIT_STACK, &rl) != 0)) {
+        erts_fprintf(stderr, "failed to set stack size for scheduler "
+                     "thread to %d bytes\n", bytes);
+        erts_usage();
+    }
 # else
+    if (modified_sched_thread_suggested_stack_size) {
 	erts_fprintf(stderr, "no OS support for dynamic stack size limit\n");
-	erts_usage();    
-# endif
+	erts_usage();
     }
+    /* Be conservative and hope it is not more than 64 kWords... */
+    stacksize = 64*1024*sizeof(void *);
+# endif
+
+    erts_scheduler_stack_limit = erts_calc_stacklimit(&c, stacksize);
 }
+
 #endif
 
 void
@@ -1299,12 +1318,11 @@ erl_start(int argc, char **argv)
 	port_tab_sz_ignore_files = 1;
     }
 
-#if (defined(__APPLE__) && defined(__MACH__)) || defined(__DARWIN__)
     /*
-     * The default stack size on MacOS X is too small for pcre.
+     * A default stack size suitable for pcre which might use quite
+     * a lot of stack.
      */
-    erts_sched_thread_suggested_stack_size = 256;
-#endif
+    erts_sched_thread_suggested_stack_size = ERTS_DEFAULT_SCHED_STACK_SIZE;
 
 #ifdef DEBUG
     verbose = DEBUG_DEFAULT;
@@ -1927,6 +1945,7 @@ erl_start(int argc, char **argv)
 		/* suggested stack size (Kilo Words) for scheduler threads */
 		arg = get_arg(sub_param+2, argv[i+1], &i);
 		erts_sched_thread_suggested_stack_size = atoi(arg);
+                modified_sched_thread_suggested_stack_size = 1;
 
 		if ((erts_sched_thread_suggested_stack_size
 		     < ERTS_SCHED_THREAD_MIN_STACK_SIZE)
@@ -2236,6 +2255,9 @@ erl_start(int argc, char **argv)
     boot_argc = argc - i;  /* Number of arguments to init */
     boot_argv = &argv[i];
 
+    if (erts_sched_thread_suggested_stack_size < ERTS_MIN_SCHED_STACK_SIZE)
+        erts_sched_thread_suggested_stack_size = ERTS_MIN_SCHED_STACK_SIZE;
+
     erl_init(ncpu,
 	     proc_tab_sz,
 	     legacy_proc_tab,
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index c4c848f49f..139394680a 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -1136,6 +1136,11 @@ void erts_short_init(void);
 void erl_start(int, char**);
 void erts_usage(void);
 Eterm erts_preloaded(Process* p);
+
+#ifndef ERTS_SMP
+extern void *erts_scheduler_stack_limit;
+#endif
+
 /* erl_md5.c */
 
 typedef struct {
@@ -1198,6 +1203,11 @@ Uint64 erts_timestamp_millis(void);
 
 Export* erts_find_function(Eterm, Eterm, unsigned int, ErtsCodeIndex);
 
+void *erts_calc_stacklimit(char *prev_c, UWord stacksize);
+int erts_check_below_limit(char *ptr, char *limit);
+int erts_check_above_limit(char *ptr, char *limit);
+void *erts_ptr_id(void *ptr);
+
 Eterm store_external_or_ref_in_proc_(Process *, Eterm);
 Eterm store_external_or_ref_(Uint **, ErlOffHeap*, Eterm);
 
@@ -1233,6 +1243,11 @@ void erts_init_external(void);
 /* erl_map.c */
 void erts_init_map(void);
 
+/* beam_debug.c */
+UWord erts_check_stack_recursion_downwards(char *start_c);
+UWord erts_check_stack_recursion_upwards(char *start_c);
+int erts_is_above_stack_limit(char *ptr);
+
 /* erl_unicode.c */
 void erts_init_unicode(void);
 Sint erts_unicode_set_loop_limit(Sint limit);
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 144dd60d21..24de35696c 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -602,6 +602,8 @@ __decl_noreturn void __noreturn erts_exit(int n, char*, ...);
 
 Eterm erts_check_io_info(void *p);
 
+UWord erts_sys_get_page_size(void);
+
 /* Size of misc memory allocated from system dependent code */
 Uint erts_sys_misc_mem_sz(void);
 
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 092a5320ba..8f3f48f38f 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -4835,6 +4835,53 @@ Uint64 erts_timestamp_millis(void)
 #endif
 }
 
+void *
+erts_calc_stacklimit(char *prev_c, UWord stacksize)
+{
+    /*
+     * We *don't* want this function inlined, i.e., it is
+     * risky to call this function from another function
+     * in utils.c
+     */
+
+    UWord pagesize = erts_sys_get_page_size();
+    char c;
+    char *start;
+    if (&c > prev_c) {
+        start = (char *) ((((UWord) prev_c) / pagesize) * pagesize);
+        return (void *) (start + stacksize);
+    }
+    else {
+        start = (char *) (((((UWord) prev_c) - 1) / pagesize + 1) * pagesize);
+        return (void *) (start - stacksize);
+    }
+}
+
+/*
+ * erts_check_below_limit() and
+ * erts_check_above_limit() are put
+ * in utils.c in order to prevent
+ * inlining.
+ */
+
+int
+erts_check_below_limit(char *ptr, char *limit)
+{
+    return ptr < limit;
+}
+
+int
+erts_check_above_limit(char *ptr, char *limit)
+{
+    return ptr > limit;
+}
+
+void *
+erts_ptr_id(void *ptr)
+{
+    return ptr;
+}
+
 #ifdef DEBUG
 /*
  * Handy functions when using a debugger - don't use in the code!