BEAM loader: Break out handling of ranges into beam_ranges.c

Having the entire implementation of range handling (address table)
in one source file will help when we'll need to update the ranges
without stopping all schedulers in the next commit.

6 files changed, 241 insertions, 194 deletions

diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index 7b17790d3a..8fe11746ee 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -44,7 +44,6 @@ static void decrement_refc(BeamInstr* code);
 static int is_native(BeamInstr* code);
 static int any_heap_ref_ptrs(Eterm* start, Eterm* end, char* mod_start, Uint mod_size);
 static int any_heap_refs(Eterm* start, Eterm* end, char* mod_start, Uint mod_size);
-static void remove_from_address_table(BeamInstr* code);
 
 Eterm
 load_module_2(BIF_ALIST_2)
@@ -449,7 +448,7 @@ BIF_RETTYPE finish_after_on_load_2(BIF_ALIST_2)
 	modp->curr.code = NULL;
 	modp->curr.code_length = 0;
 	modp->curr.catches = BEAM_CATCHES_NIL;
-	remove_from_address_table(code);
+	erts_remove_from_ranges(code);
     }
     erts_smp_thr_progress_unblock();
     erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
@@ -754,7 +753,7 @@ purge_module(int module)
 	    modp->old.code = NULL;
 	    modp->old.code_length = 0;
 	    modp->old.catches = BEAM_CATCHES_NIL;
-	    remove_from_address_table(code);
+	    erts_remove_from_ranges(code);
 	    ret = 0;
 	}
 	erts_rwunlock_old_code(code_ix);
@@ -780,25 +779,6 @@ decrement_refc(BeamInstr* code)
     }
 }
 
-static void
-remove_from_address_table(BeamInstr* code)
-{
-    int i;
-
-    for (i = 0; i < num_loaded_modules; i++) {
-	if (modules[i].start == code) {
-	    num_loaded_modules--;
-	    while (i < num_loaded_modules) {
-		modules[i] = modules[i+1];
-		i++;
-	    }
-	    mid_module = &modules[num_loaded_modules/2];
-	    return;
-	}
-    }
-    ASSERT(0);			/* Not found? */
-}
-
 
 /*
  * Move code from current to old.
diff --git a/erts/emulator/beam/beam_load.c b/erts/emulator/beam/beam_load.c
index fc3e395e91..873b94d175 100644
--- a/erts/emulator/beam/beam_load.c
+++ b/erts/emulator/beam/beam_load.c
@@ -352,27 +352,6 @@ typedef struct LoaderState {
     int loc_size;		/* Size of location info in bytes (2/4) */
 } LoaderState;
 
-/*
- * Layout of the line table.
- */
-
-#define MI_LINE_FNAME_PTR 0
-#define MI_LINE_LOC_TAB 1
-#define MI_LINE_LOC_SIZE 2
-#define MI_LINE_FUNC_TAB 3
-
-#define LINE_INVALID_LOCATION (0)
-
-/*
- * Macros for manipulating locations.
- */
-
-#define IS_VALID_LOCATION(File, Line) \
-    ((unsigned) (File) < 255 && (unsigned) (Line) < ((1 << 24) - 1))
-#define MAKE_LOCATION(File, Line) (((File) << 24) | (Line))
-#define LOC_FILE(Loc) ((Loc) >> 24)
-#define LOC_LINE(Loc) ((Loc) & ((1 << 24)-1))
-
 #define GetTagAndValue(Stp, Tag, Val)					\
    do {									\
       BeamInstr __w;							\
@@ -549,22 +528,9 @@ static Eterm native_addresses(Process* p, Eterm mod);
 int patch_funentries(Eterm Patchlist);
 int patch(Eterm Addresses, Uint fe);
 static int safe_mul(UWord a, UWord b, UWord* resp);
-static void lookup_loc(FunctionInfo* fi, BeamInstr* pc,
-		       BeamInstr* modp, int idx);
-
 
 static int must_swap_floats;
 
-/*
- * The following variables keep a sorted list of address ranges for
- * each module.  It allows us to quickly find a function given an
- * instruction pointer.
- */
-Range* modules = NULL;	    /* Sorted lists of module addresses. */
-int num_loaded_modules;	    /* Number of loaded modules. */
-int allocated_modules;	    /* Number of slots allocated. */
-Range* mid_module = NULL;   /* Cached search start point */
-
 Uint erts_total_code_size;
 /**********************************************************************/
 
@@ -580,11 +546,7 @@ void init_load(void)
     f.fd = 1.0;
     must_swap_floats = (f.fw[0] == 0);
 
-    allocated_modules = 128;
-    modules = (Range *) erts_alloc(ERTS_ALC_T_MODULE_REFS,
-				   allocated_modules*sizeof(Range));
-    mid_module = modules;
-    num_loaded_modules = 0;
+    erts_init_ranges();
 }
 
 static void
@@ -955,7 +917,6 @@ insert_new_code(Process *c_p, ErtsProcLocks c_p_locks,
 {
     Module* modp;
     Eterm retval;
-    int i;
 
     if ((retval = beam_make_current_old(c_p, c_p_locks, module)) != NIL) {
 	erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
@@ -977,25 +938,10 @@ insert_new_code(Process *c_p, ErtsProcLocks c_p_locks,
     modp->curr.catches = BEAM_CATCHES_NIL; /* Will be filled in later. */
 
     /*
-     * Update address table (used for finding a function from a PC value).
+     * Update ranges (used for finding a function from a PC value).
      */
 
-    if (num_loaded_modules == allocated_modules) {
-	allocated_modules *= 2;
-	modules = (Range *) erts_realloc(ERTS_ALC_T_MODULE_REFS,
-					 (void *) modules,
-					 allocated_modules * sizeof(Range));
-    }
-    for (i = num_loaded_modules; i > 0; i--) {
-	if (code > modules[i-1].start) {
-	    break;
-	}
-	modules[i] = modules[i-1];
-    }
-    modules[i].start = code;
-    modules[i].end = (BeamInstr *) (((byte *)code) + size);
-    num_loaded_modules++;
-    mid_module = &modules[num_loaded_modules/2];
+    erts_update_ranges(code, size);
     return NIL;
 }
 
@@ -5306,113 +5252,6 @@ compilation_info_for_module(Process* p, /* Process whose heap to use. */
 }
 
 /*
- * Find a function from the given pc and fill information in
- * the FunctionInfo struct. If the full_info is non-zero, fill
- * in all available information (including location in the
- * source code). If no function is found, the 'current' field
- * will be set to NULL.
- */
-
-void
-erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info)
-{
-    Range* low = modules;
-    Range* high = low + num_loaded_modules;
-    Range* mid = mid_module;
-
-    fi->current = NULL;
-    fi->needed = 5;
-    fi->loc = LINE_INVALID_LOCATION;
-    while (low < high) {
-	if (pc < mid->start) {
-	    high = mid;
-	} else if (pc > mid->end) {
-	    low = mid + 1;
-	} else {
-	    BeamInstr** low1 = (BeamInstr **) (mid->start + MI_FUNCTIONS);
-	    BeamInstr** high1 = low1 + mid->start[MI_NUM_FUNCTIONS];
-	    BeamInstr** mid1;
-
-	    while (low1 < high1) {
-		mid1 = low1 + (high1-low1) / 2;
-		if (pc < mid1[0]) {
-		    high1 = mid1;
-		} else if (pc < mid1[1]) {
-		    mid_module = mid;
-		    fi->current = mid1[0]+2;
-		    if (full_info) {
-			BeamInstr** fp = (BeamInstr **) (mid->start +
-							 MI_FUNCTIONS);
-			int idx = mid1 - fp;
-			lookup_loc(fi, pc, mid->start, idx);
-		    }
-		    return;
-		} else {
-		    low1 = mid1 + 1;
-		}
-	    }
-	    return;
-	}
-	mid = low + (high-low) / 2;
-    }
-}
-
-static void
-lookup_loc(FunctionInfo* fi, BeamInstr* orig_pc, BeamInstr* modp, int idx)
-{
-    Eterm* line = (Eterm *) modp[MI_LINE_TABLE];
-    Eterm* low;
-    Eterm* high;
-    Eterm* mid;
-    Eterm pc;
-
-    if (line == 0) {
-	return;
-    }
-
-    pc = (Eterm) (BeamInstr) orig_pc;
-    fi->fname_ptr = (Eterm *) (BeamInstr) line[MI_LINE_FNAME_PTR];
-    low = (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB+idx];
-    high = (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB+idx+1];
-    while (high > low) {
-	mid = low + (high-low) / 2;
-	if (pc < mid[0]) {
-	    high = mid;
-	} else if (pc < mid[1]) {
-	    int file;
-	    int index = mid - (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB];
-
-	    if (line[MI_LINE_LOC_SIZE] == 2) {
-		Uint16* loc_table =
-		    (Uint16 *) (BeamInstr) line[MI_LINE_LOC_TAB];
-		fi->loc = loc_table[index];
-	    } else {
-		Uint32* loc_table =
-		    (Uint32 *) (BeamInstr) line[MI_LINE_LOC_TAB];
-		ASSERT(line[MI_LINE_LOC_SIZE] == 4);
-		fi->loc = loc_table[index];
-	    }
-	    if (fi->loc == LINE_INVALID_LOCATION) {
-		return;
-	    }
-	    fi->needed += 3+2+3+2;
-	    file = LOC_FILE(fi->loc);
-	    if (file == 0) {
-		/* Special case: Module name with ".erl" appended */
-		Atom* mod_atom = atom_tab(atom_val(fi->current[0]));
-		fi->needed += 2*(mod_atom->len+4);
-	    } else {
-		Atom* ap = atom_tab(atom_val((fi->fname_ptr)[file-1]));
-		fi->needed += 2*ap->len;
-	    }
-	    return;
-	} else {
-	    low = mid + 1;
-	}
-    }
-}
-
-/*
  * Build a single {M,F,A,Loction} item to be part of
  * a stack trace.
  */
diff --git a/erts/emulator/beam/beam_load.h b/erts/emulator/beam/beam_load.h
index 997ba197db..9da692625b 100644
--- a/erts/emulator/beam/beam_load.h
+++ b/erts/emulator/beam/beam_load.h
@@ -61,11 +61,6 @@ typedef struct {
  * instruction pointer.
  */
 
-extern Range* modules;
-extern int num_loaded_modules;
-extern int allocated_modules;
-extern Range* mid_module;
-
 /* Total code size in bytes */
 extern Uint erts_total_code_size;
 /*
@@ -126,4 +121,26 @@ extern Uint erts_total_code_size;
  */
 
 #define MI_FUNCTIONS         13
+
+/*
+ * Layout of the line table.
+ */
+
+#define MI_LINE_FNAME_PTR 0
+#define MI_LINE_LOC_TAB 1
+#define MI_LINE_LOC_SIZE 2
+#define MI_LINE_FUNC_TAB 3
+
+#define LINE_INVALID_LOCATION (0)
+
+/*
+ * Macros for manipulating locations.
+ */
+
+#define IS_VALID_LOCATION(File, Line) \
+    ((unsigned) (File) < 255 && (unsigned) (Line) < ((1 << 24) - 1))
+#define MAKE_LOCATION(File, Line) (((File) << 24) | (Line))
+#define LOC_FILE(Loc) ((Loc) >> 24)
+#define LOC_LINE(Loc) ((Loc) & ((1 << 24)-1))
+
 #endif /* _BEAM_LOAD_H */
diff --git a/erts/emulator/beam/beam_ranges.c b/erts/emulator/beam/beam_ranges.c
new file mode 100644
index 0000000000..063b319f7a
--- /dev/null
+++ b/erts/emulator/beam/beam_ranges.c
@@ -0,0 +1,205 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2012. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "sys.h"
+#include "erl_vm.h"
+#include "global.h"
+#include "beam_load.h"
+
+static void lookup_loc(FunctionInfo* fi, BeamInstr* pc,
+		       BeamInstr* modp, int idx);
+
+/*
+ * The following variables keep a sorted list of address ranges for
+ * each module.  It allows us to quickly find a function given an
+ * instruction pointer.
+ */
+static Range* modules = NULL;  /* Sorted lists of module addresses. */
+static int num_loaded_modules; /* Number of loaded modules. */
+static int allocated_modules;  /* Number of slots allocated. */
+static Range* mid_module = NULL; /* Cached search start point */
+
+void
+erts_init_ranges(void)
+{
+    allocated_modules = 128;
+    modules = (Range *) erts_alloc(ERTS_ALC_T_MODULE_REFS,
+				   allocated_modules*sizeof(Range));
+    mid_module = modules;
+    num_loaded_modules = 0;
+}
+
+void
+erts_update_ranges(BeamInstr* code, Uint size)
+{
+    int i;
+
+    if (num_loaded_modules == allocated_modules) {
+	allocated_modules *= 2;
+	modules = (Range *) erts_realloc(ERTS_ALC_T_MODULE_REFS,
+					 (void *) modules,
+					 allocated_modules * sizeof(Range));
+    }
+    for (i = num_loaded_modules; i > 0; i--) {
+	if (code > modules[i-1].start) {
+	    break;
+	}
+	modules[i] = modules[i-1];
+    }
+    modules[i].start = code;
+    modules[i].end = (BeamInstr *) (((byte *)code) + size);
+    num_loaded_modules++;
+    mid_module = &modules[num_loaded_modules/2];
+}
+
+void
+erts_remove_from_ranges(BeamInstr* code)
+{
+    int i;
+
+    for (i = 0; i < num_loaded_modules; i++) {
+	if (modules[i].start == code) {
+	    num_loaded_modules--;
+	    while (i < num_loaded_modules) {
+		modules[i] = modules[i+1];
+		i++;
+	    }
+	    mid_module = &modules[num_loaded_modules/2];
+	    return;
+	}
+    }
+    ASSERT(0);			/* Not found? */
+}
+
+Uint
+erts_ranges_sz(void)
+{
+    return allocated_modules*sizeof(Range);
+}
+
+/*
+ * Find a function from the given pc and fill information in
+ * the FunctionInfo struct. If the full_info is non-zero, fill
+ * in all available information (including location in the
+ * source code). If no function is found, the 'current' field
+ * will be set to NULL.
+ */
+
+void
+erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info)
+{
+    Range* low = modules;
+    Range* high = low + num_loaded_modules;
+    Range* mid = mid_module;
+
+    fi->current = NULL;
+    fi->needed = 5;
+    fi->loc = LINE_INVALID_LOCATION;
+    while (low < high) {
+	if (pc < mid->start) {
+	    high = mid;
+	} else if (pc > mid->end) {
+	    low = mid + 1;
+	} else {
+	    BeamInstr** low1 = (BeamInstr **) (mid->start + MI_FUNCTIONS);
+	    BeamInstr** high1 = low1 + mid->start[MI_NUM_FUNCTIONS];
+	    BeamInstr** mid1;
+
+	    while (low1 < high1) {
+		mid1 = low1 + (high1-low1) / 2;
+		if (pc < mid1[0]) {
+		    high1 = mid1;
+		} else if (pc < mid1[1]) {
+		    mid_module = mid;
+		    fi->current = mid1[0]+2;
+		    if (full_info) {
+			BeamInstr** fp = (BeamInstr **) (mid->start +
+							 MI_FUNCTIONS);
+			int idx = mid1 - fp;
+			lookup_loc(fi, pc, mid->start, idx);
+		    }
+		    return;
+		} else {
+		    low1 = mid1 + 1;
+		}
+	    }
+	    return;
+	}
+	mid = low + (high-low) / 2;
+    }
+}
+
+static void
+lookup_loc(FunctionInfo* fi, BeamInstr* orig_pc, BeamInstr* modp, int idx)
+{
+    Eterm* line = (Eterm *) modp[MI_LINE_TABLE];
+    Eterm* low;
+    Eterm* high;
+    Eterm* mid;
+    Eterm pc;
+
+    if (line == 0) {
+	return;
+    }
+
+    pc = (Eterm) (BeamInstr) orig_pc;
+    fi->fname_ptr = (Eterm *) (BeamInstr) line[MI_LINE_FNAME_PTR];
+    low = (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB+idx];
+    high = (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB+idx+1];
+    while (high > low) {
+	mid = low + (high-low) / 2;
+	if (pc < mid[0]) {
+	    high = mid;
+	} else if (pc < mid[1]) {
+	    int file;
+	    int index = mid - (Eterm *) (BeamInstr) line[MI_LINE_FUNC_TAB];
+
+	    if (line[MI_LINE_LOC_SIZE] == 2) {
+		Uint16* loc_table =
+		    (Uint16 *) (BeamInstr) line[MI_LINE_LOC_TAB];
+		fi->loc = loc_table[index];
+	    } else {
+		Uint32* loc_table =
+		    (Uint32 *) (BeamInstr) line[MI_LINE_LOC_TAB];
+		ASSERT(line[MI_LINE_LOC_SIZE] == 4);
+		fi->loc = loc_table[index];
+	    }
+	    if (fi->loc == LINE_INVALID_LOCATION) {
+		return;
+	    }
+	    fi->needed += 3+2+3+2;
+	    file = LOC_FILE(fi->loc);
+	    if (file == 0) {
+		/* Special case: Module name with ".erl" appended */
+		Atom* mod_atom = atom_tab(atom_val(fi->current[0]));
+		fi->needed += 2*(mod_atom->len+4);
+	    } else {
+		Atom* ap = atom_tab(atom_val((fi->fname_ptr)[file-1]));
+		fi->needed += 2*ap->len;
+	    }
+	    return;
+	} else {
+	    low = mid + 1;
+	}
+    }
+}
diff --git a/erts/emulator/beam/erl_alloc.c b/erts/emulator/beam/erl_alloc.c
index 07a2539367..bf7c53bf1a 100644
--- a/erts/emulator/beam/erl_alloc.c
+++ b/erts/emulator/beam/erl_alloc.c
@@ -2187,7 +2187,7 @@ erts_memory(int *print_to_p, void *print_to_arg, void *proc, Eterm earg)
 	size.code += export_table_sz();
 	size.code += export_list_size(erts_active_code_ix()) * sizeof(Export);
 	size.code += erts_fun_table_sz();
-	size.code += allocated_modules*sizeof(Range);
+	size.code += erts_ranges_sz();
 	size.code += erts_total_code_size;
     }
 
@@ -2350,7 +2350,7 @@ erts_allocated_areas(int *print_to_p, void *print_to_arg, void *proc)
 
     values[i].arity = 2;
     values[i].name = "module_refs";
-    values[i].ui[0] = allocated_modules*sizeof(Range);
+    values[i].ui[0] = erts_ranges_sz();
     i++;
 
     values[i].arity = 2;
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 4ce6ed5280..05517ac9e8 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -884,12 +884,18 @@ void init_load(void);
 BeamInstr* find_function_from_pc(BeamInstr* pc);
 Eterm* erts_build_mfa_item(FunctionInfo* fi, Eterm* hp,
 			   Eterm args, Eterm* mfa_p);
-void erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info);
 void erts_set_current_function(FunctionInfo* fi, BeamInstr* current);
 Eterm erts_module_info_0(Process* p, Eterm module);
 Eterm erts_module_info_1(Process* p, Eterm module, Eterm what);
 Eterm erts_make_stub_module(Process* p, Eterm Mod, Eterm Beam, Eterm Info);
 
+/* beam_ranges.c */
+void erts_init_ranges(void);
+void erts_update_ranges(BeamInstr* code, Uint size);
+void erts_remove_from_ranges(BeamInstr* code);
+Uint erts_ranges_sz(void);
+void erts_lookup_function_info(FunctionInfo* fi, BeamInstr* pc, int full_info);
+
 /* break.c */
 void init_break_handler(void);
 void erts_set_ignore_break(void);