porffor 0.60.5 → 0.60.7

package/compiler/2c.js

@@ -350,8 +350,11 @@ export default ({ funcs, globals, data, pages }) => {
     const typedReturns = f.returnType == null;
 
     const shouldInline = false; // f.internal;
-    if (f.name === '#main') out += `int main(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
-      else out += `${!typedReturns ? (returns ? CValtype[f.returns[0]] : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    if (f.name === '#main') {
+      out += `int ${Prefs.lambda ? 'user_main' : 'main'}(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
+    } else {
+      out += `${!typedReturns ? (returns ? CValtype[f.returns[0]] : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    }
 
     if (f.name === '__Porffor_promise_runJobs') {
       out += '}';
@@ -426,6 +429,7 @@ export default ({ funcs, globals, data, pages }) => {
         for (const name in symbols) {
           line(`*(void**)(&${name}) = dlsym(_dl, "${name}")`);
           ffiFuncs[name] = symbols[name];
+          cified.add(name, true);
         }
 
         continue;
@@ -639,9 +643,13 @@ extern ${importFunc.returns.length > 0 ? CValtype[importFunc.returns[0]] : 'void
 
               case 'time': {
                 const id = tmpId++;
-                line(`time_t _time_t${id}`);
-                line(`time(&_time_t${id})`);
-                line(`f64 _time_out${id} = (f64)_time_t${id} * 1000.0`);
+                platformSpecific(`
+time_t _time_t${id};
+time(&_time_t${id});
+f64 _time_out${id} = (f64)_time_t${id} * 1000.0;`, `
+struct timespec _ts${id};
+clock_gettime(CLOCK_REALTIME, &_ts${id});
+f64 _time_out${id} = (f64)_ts${id}.tv_sec * 1000.0 + (f64)_ts${id}.tv_nsec / 1.0e6;`);
                 vals.push(`_time_out${id}`);
 
                 includes.set('time.h', true);
@@ -969,6 +977,175 @@ extern ${importFunc.returns.length > 0 ? CValtype[importFunc.returns[0]] : 'void
     return `${!typedReturns ? (returns ? CValtype[f.returns[0]] : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${ffiFuncs[f.name] ? '(*' : ''}${sanitize(f.name)}${ffiFuncs[f.name] ? ')' : ''}(${rawParams(f).map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')});`;
   }).join('\n'));
 
+  if (Prefs.lambda) {
+    includes.set('stdio.h', true);
+    includes.set('stdlib.h', true);
+    includes.set('string.h', true);
+    includes.set('unistd.h', true);
+    includes.set('netdb.h', true);
+    includes.set('sys/socket.h', true);
+    includes.set('signal.h', true);
+    includes.set('execinfo.h', true);
+
+    let copyGlobals = '';
+    let restoreGlobals = '';
+    for (const x in globals) {
+      const g = globals[x];
+
+      copyGlobals += `${CValtype[g.type]} copy_${sanitize(x)} = ${sanitize(x)};\n`;
+      restoreGlobals += `${sanitize(x)} = copy_${sanitize(x)};\n`;
+    }
+
+    const lambdaWrapper = `
+#define BUF_SIZE 65536
+
+// minimal http send/receive
+static int send_http(const char *host, const char *port, const char *req, char *resp, size_t resp_size) {
+  struct addrinfo hints = {0}, *res;
+  int sock;
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  if (getaddrinfo(host, port, &hints, &res) != 0) return -1;
+
+  sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+  if (sock < 0) return -1;
+  if (connect(sock, res->ai_addr, res->ai_addrlen) != 0) {
+    close(sock);
+    freeaddrinfo(res);
+    return -1;
+  }
+
+  write(sock, req, strlen(req));
+
+  int len = 0;
+  if (resp) {
+    len = read(sock, resp, resp_size - 1);
+    if (len >= 0) resp[len] = '\\0';
+  }
+
+  close(sock);
+  freeaddrinfo(res);
+  return len;
+}
+
+void crash_handler(int sig) {
+  void *array[20];
+  size_t size = backtrace(array, 20);
+  fprintf(stderr, "Caught signal %d\\n", sig);
+  backtrace_symbols_fd(array, size, STDERR_FILENO);
+  _exit(1);
+}
+
+int main(void) {
+  signal(SIGSEGV, crash_handler);
+  signal(SIGABRT, crash_handler);
+  signal(SIGBUS, crash_handler);
+  signal(SIGILL, crash_handler);
+
+  user_main();
+
+  i32 _memory_pages = _memoryPages;
+  char* _memory_clone = calloc(1, _memory_pages * ${PageSize});
+  memcpy(_memory_clone, _memory, _memory_pages * ${PageSize});
+
+  ${copyGlobals}
+
+  char *api = getenv("AWS_LAMBDA_RUNTIME_API");
+  if (!api) {
+      // Not in Lambda — error
+      printf("AWS_LAMBDA_RUNTIME_API not set\\n");
+      exit(1);
+  }
+
+  char host[256], port[16] = "80";
+  char *colon = strchr(api, ':');
+  if (colon) {
+      strncpy(host, api, colon - api);
+      host[colon - api] = '\\0';
+      strncpy(port, colon + 1, sizeof(port) - 1);
+  } else {
+      strncpy(host, api, sizeof(host) - 1);
+  }
+
+  char req[BUF_SIZE], resp[BUF_SIZE];
+  char request_id[128];
+
+  i32 request_count = 0;
+  while (1) {
+    // 1. GET next event
+    snprintf(req, sizeof(req),
+              "GET /2018-06-01/runtime/invocation/next HTTP/1.1\\r\\n"
+              "Host: %s\\r\\n\\r\\n", host);
+    if (send_http(host, port, req, resp, sizeof(resp)) <= 0) {
+      fprintf(stderr, "send_http failed\\n");
+      break;
+    }
+
+    char *rid = strstr(resp, "Lambda-Runtime-Aws-Request-Id: ");
+    if (!rid) {
+      fprintf(stderr, "No Request ID header in response:\\n%s\\n", resp);
+      break;
+    }
+
+    rid += strlen("Lambda-Runtime-Aws-Request-Id: ");
+    char *end = strchr(rid, '\\r');
+    if (!end) {
+      fprintf(stderr, "No CR after Request ID in response:\\n%s\\n", resp);
+      break;
+    }
+    size_t rid_len = end - rid;
+    strncpy(request_id, rid, rid_len);
+    request_id[rid_len] = '\\0';
+
+    // 2. Parse event data from response body
+    char *body = strstr(resp, "\\r\\n\\r\\n");
+    void *event = NULL;
+    if (body) {
+      body += 4; // skip \\r\\n\\r\\n
+      event = body;
+    }
+
+    if (request_count++ > 0) {
+      _memoryPages = _memory_pages;
+      free(_memory);
+      _memory = calloc(1, _memory_pages * ${PageSize});
+      memcpy(_memory, _memory_clone, _memory_pages * ${PageSize});
+
+      ${restoreGlobals}
+    }
+
+    // Call handler function and JSON.stringify the result
+    // size_t eventLen = strlen(event);
+    // i32 eventPtr = __Porffor_allocateBytes(eventLen + 4);
+    // memcpy((char*)eventPtr, &eventLen, 4);
+    // memcpy((char*)eventPtr + 4, event, eventLen);
+
+    // char* resp = _memory + (i32)__Porffor_handler((f64)eventPtr, 195).value + 4;
+    i32 ret = (i32)__Porffor_handler().value;
+    char* ret_str = _memory + ret + 4;
+    i32 ret_str_len = *((i32*)(ret_str - 4));
+
+    // 3. POST response
+    snprintf(req, sizeof(req),
+              "POST /2018-06-01/runtime/invocation/%s/response HTTP/1.1\\r\\n"
+              "Host: %s\\r\\n"
+              "Content-Type: text/plain\\r\\n"
+              "Content-Length: %zu\\r\\n\\r\\n"
+              "%s", request_id, host, ret_str_len, ret_str);
+    send_http(host, port, req, resp, sizeof(resp));
+  }
+  return 0;
+}`;
+    out += lambdaWrapper;
+
+    // preallocate 1 chunk allocator chunk
+//     out = out.replace(`_memory = calloc(1, _memoryPages * ${PageSize});\n`, `
+// jjporfjjchunkPtr = _memoryPages * 65536;
+// jjporfjjchunkOffset = 0;
+// _memoryPages += 16;
+// _memory = calloc(1, _memoryPages * ${PageSize});`);
+  }
+
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
   out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 

package/compiler/codegen.js

@@ -2638,7 +2638,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       args.push({
         type: 'ArrayExpression',
         elements: restArgs,
-        _doNotMarkTypeUsed: true
+        _doNotMarkTypeUsed: true,
+        _staticAlloc: func.internal
       });
     }
   }
@@ -5594,7 +5595,7 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', static
   const out = [];
   let pointer;
 
-  if (staticAlloc) {
+  if (staticAlloc || decl._staticAlloc) {
     const uniqueName = name === '$undeclared' ? name + uniqId() : name;
 
     const ptr = allocPage({ scope, pages }, uniqueName);

package/compiler/index.js

@@ -284,7 +284,7 @@ int m()`);
       console.log(`\u001b[2m[${total.toFixed(0)}ms]\u001b[0m \u001b[32mcompiled ${globalThis.file} \u001b[90m->\u001b[0m \u001b[92m${outFile}\u001b[90m (${(fs.statSync(outFile).size / 1000).toFixed(1)}KB)\u001b[0m`);
     }
 
-    if (process.version) process.exit();
+    if (process.version && !Prefs.lambda) process.exit();
   }
 
   if (target === 'native') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.60.5",
+  "version": "0.60.7",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.60.5';
+globalThis.version = '0.60.7';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -9,7 +9,7 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
 
 const start = performance.now();
 
-if (process.argv.includes('--help') || process.argv.includes('-h')) {
+const help = () => {
   // description + version
   console.log(`\x1B[1m\x1B[35mPorffor\x1B[0m is a JavaScript/TypeScript engine/compiler/runtime. \x1B[2m(${globalThis.version})\x1B[0m`);
 
@@ -23,6 +23,7 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
     wasm: [ 34, 'foo.js foo.wasm', 'Compile to a Wasm binary' ],
     c: [ 94, 'foo.js foo.c', 'Compile to C source code' ],
     native: [ 94, 'foo.js foo', 'Compile to a native binary' ],
+    lambda: [ 36, 'foo.js function.zip', 'Compile Lambda code to a deployable zip' ],
 
     'Analyze': [],
     profile: [ 93, 'foo.js', 'View detailed func-by-func performance' ],
@@ -81,6 +82,10 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
 
   console.log();
   process.exit(0);
+};
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  help();
 }
 
 const done = async () => {
@@ -90,7 +95,9 @@ const done = async () => {
 };
 
 let file = process.argv.slice(2).find(x => x[0] !== '-');
-if (['precompile', 'run', 'wasm', 'native', 'c', 'profile', 'debug', 'dissect'].includes(file)) {
+if (file === 'help') help();
+
+if (['precompile', 'run', 'wasm', 'native', 'c', 'lambda', 'profile', 'debug'].includes(file)) {
   // remove this arg
   process.argv.splice(process.argv.indexOf(file), 1);
 
@@ -113,9 +120,10 @@ if (['precompile', 'run', 'wasm', 'native', 'c', 'profile', 'debug', 'dissect'].
     process.argv.push(`--target=${file}`);
   }
 
-  // if (file === 'dissect') {
-  //   process.argv.push('--asur', '--wasm-debug');
-  // }
+  if (file === 'lambda') {
+    await import('./lambda.js');
+    await done();
+  }
 
   file = process.argv.slice(2).find(x => x[0] !== '-');
 

package/runtime/lambda.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { execSync } from 'node:child_process';
+import compile from '../compiler/wrap.js';
+
+// Parse arguments
+const args = process.argv.slice(2);
+const sourceFile = args.find(x => x[0] !== '-' && !x.includes('='));
+const outputZip = args.find(x => x[0] !== '-' && !x.includes('=') && x !== sourceFile);
+
+console.log(`Compiling ${sourceFile} to AWS Lambda function...`);
+
+// Read source file
+const source = `${fs.readFileSync(sourceFile, 'utf8').replace('handler = async', 'handler =')}
+
+export const __Porffor_handler = () => {
+  const res = handler();
+  if (Porffor.type(res) == Porffor.TYPES.bytestring) return res;
+  return JSON.stringify(res);
+};`;
+
+const binaryPath = 'bootstrap';
+const cPath = 'bootstrap.c';
+
+Prefs.allocator = 'oneshot'; // oneshot is faster for lambda
+Prefs.target = 'c';
+Prefs.o = cPath;
+Prefs.lambda = true;
+
+compile(source, true);
+
+if (Prefs.d) execSync(`gcc -lm -O0 -g -flto -march=x86-64-v3 -o ${binaryPath} ${cPath}`, { stdio: 'inherit' });
+  else execSync(`gcc -lm -Os -s -flto -march=x86-64-v3 -o ${binaryPath} ${cPath}`, { stdio: 'inherit' });
+
+try {
+  execSync(`zip -r "${outputZip}" ${binaryPath}`, { stdio: 'inherit' });
+  console.log(`Lambda function packaged to ${outputZip}`);
+} catch (e) {
+  console.error('Error creating zip file:', e.message);
+  process.exit(1);
+} finally {
+  if (!Prefs.d) {
+    fs.rmSync(binaryPath, { force: true });
+    fs.rmSync(cPath, { force: true });
+  }
+}

package/foo.js

@@ -1,9 +0,0 @@
-const func = () => {
-  let before = 0;
-
-  TypeError('wow');
-
-  let after = 1;
-};
-
-func();