Store memory initialization in string literal if requested

With “--memory-init-file 0 -s MEM_INIT_METHOD=2” on the command line, the
generated JavaScript file will contain a string literal representing the
initial content of the memory buffer.

The MEM_INIT_METHOD defaults to 0 but gets set to 1 if --memory-init-file is
being used.  Conversely, setting it to 1 without --memory-init-file will
cause it to revert to 0.  That way, we can use the setting in the postamble,
without too many changes in other places.

Since memory is initialized to all zero, trailing zeros can be omitted.
This change affects the file-based initialization as well, but not when
using emterpretify.

Author: gagern

emcc

@@ -1267,6 +1267,10 @@ try:
   # Emscripten
   logging.debug('LLVM => JS')
   extra_args = [] if not js_libraries else ['--libraries', ','.join(map(os.path.abspath, js_libraries))]
+  if memory_init_file:
+    shared.Settings.MEM_INIT_METHOD = 1
+  elif shared.Settings.MEM_INIT_METHOD == 1:
+    shared.Settings.MEM_INIT_METHOD = 0
   final = shared.Building.emscripten(final, append_ext=False, extra_args=extra_args)
   if DEBUG: save_intermediate('original')
 
@@ -1318,14 +1322,26 @@ try:
 
   js_transform_tempfiles = [final]
 
-  if memory_init_file:
+  if memory_init_file or shared.Settings.MEM_INIT_METHOD == 2:
     memfile = target + '.mem'
     shared.try_delete(memfile)
     def repl(m):
       # handle chunking of the memory initializer
       s = m.groups(0)[0]
       if len(s) == 0 and not shared.Settings.EMTERPRETIFY: return m.group(0) # emterpreter must have a mem init file; otherwise, don't emit 0-size ones
-      open(memfile, 'wb').write(''.join(map(lambda x: chr(int(x or '0')), s.split(','))))
+      membytes = [int(x or '0') for x in s.split(',')]
+      if not shared.Settings.EMTERPRETIFY:
+        while membytes and membytes[-1] == 0:
+          membytes.pop()
+        if not membytes:
+          return '';
+      membytes = ''.join(map(chr, membytes))
+      if not memory_init_file:
+        s = repr(membytes)
+        hex_to_octal = lambda x: '\\%o' % int(x.group(1), 16)
+        s = re.sub(r'\\x([0-1][0-9A-Fa-f])(?:(?=[^0-9])|$)', hex_to_octal, s)
+        return 'var memoryInitializer = %s;' % s
+      open(memfile, 'wb').write(membytes)
       if DEBUG:
         # Copy into temp dir as well, so can be run there too
         shared.safe_copy(memfile, os.path.join(shared.get_emscripten_temp_dir(), os.path.basename(memfile)))

src/postamble.js

@@ -1,6 +1,12 @@
 
 // === Auto-generated postamble setup entry stuff ===
 
+#if MEM_INIT_METHOD == 2
+if (memoryInitializer) (function(s) {
+  for (var i = 0; i < s.length; ++i) HEAPU8[i] = s.charCodeAt(i);
+})(memoryInitializer);
+#else
+#if MEM_INIT_METHOD == 1
 if (memoryInitializer) {
   if (typeof Module['locateFile'] === 'function') {
     memoryInitializer = Module['locateFile'](memoryInitializer);
@@ -48,6 +54,8 @@ if (memoryInitializer) {
     }
   }
 }
+#endif
+#endif
 
 function ExitStatus(status) {
   this.name = "ExitStatus";

src/settings.js

@@ -35,6 +35,11 @@ var INVOKE_RUN = 1; // Whether we will run the main() function. Disable if you e
                     // can do with Module.callMain(), with an optional parameter of commandline args).
 var NO_EXIT_RUNTIME = 0; // If set, the runtime is not quit when main() completes (allowing code to
                          // run afterwards, for example from the browser main event loop).
+var MEM_INIT_METHOD = 0; // How to represent the initial memory content.
+                         // 0: keep array literal representing the initial memory data
+                         // 1: create a *.mem file containing the binary data of the initial memory;
+                         //    use the --memory-init-file command line switch to select this method
+                         // 2: embed a string literal representing that initial memory data
 var TOTAL_STACK = 5*1024*1024; // The total stack size. There is no way to enlarge the stack, so this
                                // value must be large enough for the program's requirements. If
                                // assertions are on, we will assert on not exceeding this, otherwise,