porffor 0.60.24 → 0.60.26

package/compiler/2c.js

@@ -985,7 +985,6 @@ f64 _time_out${id} = (f64)_ts${id}.tv_sec * 1000.0 + (f64)_ts${id}.tv_nsec / 1.0
     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 = '';
@@ -997,51 +996,64 @@ f64 _time_out${id} = (f64)_ts${id}.tv_sec * 1000.0 + (f64)_ts${id}.tv_nsec / 1.0
     }
 
     const lambdaWrapper = `
-#define BUF_SIZE 65536
+#define BUF_SIZE 8192
 
-// 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;
+static struct addrinfo* runtime_addr = NULL;
+static int runtime_sock = -1;
+
+static int init_runtime_addr(const char* host, const char* port) {
+  struct addrinfo hints = {0};
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
-  if (getaddrinfo(host, port, &hints, &res) != 0) return -1;
+  return getaddrinfo(host, port, &hints, &runtime_addr);
+}
 
-  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);
+static int get_sock(void) {
+  if (runtime_sock >= 0) return runtime_sock;
+  if (!runtime_addr) return -1;
+
+  runtime_sock = socket(runtime_addr->ai_family, runtime_addr->ai_socktype,
+                        runtime_addr->ai_protocol);
+  if (runtime_sock < 0) return -1;
+
+  int optval = 1;
+  setsockopt(runtime_sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
+
+  if (connect(runtime_sock, runtime_addr->ai_addr, runtime_addr->ai_addrlen) != 0) {
+    close(runtime_sock);
+    runtime_sock = -1;
     return -1;
   }
+  return runtime_sock;
+}
+
+static int send_http(const char* req, size_t req_size, char* resp, size_t resp_size) {
+  int sock = get_sock();
+  if (sock < 0) return -1;
 
-  write(sock, req, strlen(req));
+  ssize_t w = write(sock, req, req_size);
+  if (w != req_size) return -1;
 
   int len = 0;
   if (resp) {
     len = read(sock, resp, resp_size - 1);
-    if (len >= 0) resp[len] = '\\0';
+    if (len < 0) {
+      close(sock);
+      runtime_sock = -1;
+      return -1;
+    }
+    resp[len] = '\\0';
   }
 
-  close(sock);
-  freeaddrinfo(res);
-  return len;
-}
+  if (len == 0) {
+    close(sock);
+    runtime_sock = -1;
+  }
 
-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);
+  return len;
 }
 
 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;
@@ -1052,31 +1064,34 @@ int main(void) {
 
   char *api = getenv("AWS_LAMBDA_RUNTIME_API");
   if (!api) {
-      // Not in Lambda — error
-      printf("AWS_LAMBDA_RUNTIME_API not set\\n");
-      exit(1);
+    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);
+    strncpy(host, api, colon - api);
+    host[colon - api] = '\\0';
+    strncpy(port, colon + 1, sizeof(port) - 1);
   } else {
-      strncpy(host, api, sizeof(host) - 1);
+    strncpy(host, api, sizeof(host) - 1);
+  }
+
+  if (init_runtime_addr(host, port) != 0) {
+    fprintf(stderr, "Failed to resolve runtime host\\n");
+    return 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),
+    int req_size = 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) {
+              "Host: %s\\r\\n"
+              "Connection: keep-alive\\r\\n\\r\\n", host);
+    if (send_http(req, (size_t)req_size, resp, sizeof(resp)) <= 0) {
       fprintf(stderr, "send_http failed\\n");
       break;
     }
@@ -1098,21 +1113,12 @@ int main(void) {
     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}
-    }
+    // char *body = strstr(resp, "\\r\\n\\r\\n");
+    // void *event = NULL;
+    // if (body) {
+    //   body += 4; // skip \\r\\n\\r\\n
+    //   event = body;
+    // }
 
     // Call handler function and JSON.stringify the result
     // size_t eventLen = strlen(event);
@@ -1120,19 +1126,24 @@ int main(void) {
     // 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),
+    req_size = snprintf(req, sizeof(req),
               "POST /2018-06-01/runtime/invocation/%s/response HTTP/1.1\\r\\n"
               "Host: %s\\r\\n"
+              "Connection: close\\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));
+    send_http(req, (size_t)req_size, NULL, 0);
+
+    // reset js state after response
+    memcpy(_memory, _memory_clone, _memory_pages * ${PageSize});
+
+    ${restoreGlobals}
   }
   return 0;
 }`;

package/compiler/codegen.js

@@ -2393,7 +2393,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       protoBC.default = decl.optional ?
         withType(scope, [ number(UNDEFINED) ], TYPES.undefined) :
-        internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`, true);
+        generate(scope, {
+          ...decl,
+          _protoInternalCall: true
+        });
 
       // fallback to object prototype impl as a basic prototype chain hack
       if (protoBC[TYPES.object]) {

package/compiler/cyclone.js

@@ -91,7 +91,7 @@ export default ({ name, wasm, locals: _locals, params }, _globals) => {
       // if (Prefs.f === name) console.log(invOpcodes[opcode], stack);
       switch (opcode) {
         case Opcodes.if: {
-          if (stack.length < 1) { empty(); break; }
+          if (stack.length < 1) { reset(); break; }
           const cond = bool(pop());
 
           // find else split and end
@@ -598,7 +598,6 @@ export default ({ name, wasm, locals: _locals, params }, _globals) => {
         case Opcodes.block:
         case Opcodes.loop:
         case Opcodes.try:
-        case Opcodes.if:
         case Opcodes.else:
         case Opcodes.catch:
         case Opcodes.end: {

package/compiler/semantic.js

@@ -1,7 +1,3 @@
-// todo: sloppy vs strict mode
-// todo: function/class decls ?
-// todo: function params
-
 const varId = name => {
   const lastFunc = scopes[scopes.lastFuncs.at(-1)];
   lastFunc._variableIds ??= Object.create(null);
@@ -14,7 +10,18 @@ const varId = name => {
 };
 
 const declVar = (name, kind, node) => {
-  const parent = kind === 'var' ? scopes[scopes.lastFuncs.at(-1)] : scopes.at(-1);
+  let parent;
+  if (kind === 'var') {
+    parent = scopes[scopes.lastFuncs.at(-1)];
+    // same id for redecl
+    if (parent._variables?.[name]) {
+      parent._variables[name].node = node;
+      return;
+    }
+  } else {
+    parent = scopes.at(-1);
+  }
+
   parent._variables ??= Object.create(null);
   parent._variables[name] = { node, id: varId(name) };
 };
@@ -53,9 +60,14 @@ const analyzePattern = (kind, node) => {
 };
 
 let scopes;
-const analyze = node => {
+const analyze = (node, strict = false) => {
   if (!node) return;
 
+  const top = scopes.at(-1);
+  if (node.directive === 'use strict') {
+    top._strict = true;
+  }
+
   let openedScope = false;
   switch (node.type) {
     case 'ForStatement':
@@ -77,18 +89,31 @@ const analyze = node => {
       for (const x of node.declarations) analyzePattern(node.kind, x.id);
       break;
 
+    case 'ClassDeclaration':
+      if (node.id?.name) declVar(node.id.name, 'let', node);
+      break;
+
     case 'FunctionDeclaration':
+      if (node.id?.name) if (strict) {
+        declVar(node.id.name, 'let', node);
+      } else {
+        declVar(node.id.name, 'var', node);
+      }
     case 'FunctionExpression':
     case 'ArrowFunctionExpression':
       scopes.lastFuncs.push(scopes.length);
+      scopes.push(node);
+      openedScope = true;
+
+      for (const p of node.params) analyzePattern('var', p);
       break;
   }
 
   for (const x in node) {
     if (node[x] != null && typeof node[x] === 'object') {
-      if (node[x].type) analyze(node[x]);
+      if (node[x].type) analyze(node[x], strict || top._strict);
       if (Array.isArray(node[x])) {
-        for (const y of node[x]) analyze(y);
+        for (const y of node[x]) analyze(y, strict || top._strict);
       }
     }
   }
@@ -138,19 +163,21 @@ const annotate = node => {
     case 'CallExpression':
       if (node.callee.name === 'eval' || (node.callee.type === 'SequenceExpression' && node.callee.expressions.at(-1)?.name === 'eval')) {
         if (node.callee.type === 'SequenceExpression' || node.optional) {
-          // indirect eval, no scopes
-          node._semanticScopes = [ node ];
+          // indirect eval, only top scope
+          node._semanticScopes = [ scopes[0], node ];
           node._semanticScopes.lastFuncs = [ 0 ];
         } else {
           // direct eval, use existing scope
           node._semanticScopes = Object.assign([], scopes);
+          node._semanticScopes.push(node);
         }
       }
 
     case 'NewExpression':
       if (node.callee.name === 'Function') {
-        // todo: this is probably wrong and needs to add own new scope
-        node._semanticScopes = Object.assign([], scopes);
+        // new Function(...) - use global scope and self as scope
+        node._semanticScopes = [ scopes[0], node ];
+        node._semanticScopes.lastFuncs = [ 0, 1 ];
       }
       break;
   }

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@honk/porffor",
-  "version": "0.60.24",
+  "version": "0.60.26",
   "exports": "./compiler/wrap.js",
   "publish": {
     "exclude": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.60.24",
+  "version": "0.60.26",
   "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.24';
+globalThis.version = '0.60.26';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/runtime/lambda.js

@@ -2,6 +2,7 @@
 import fs from 'node:fs';
 import { execSync } from 'node:child_process';
 import compile from '../compiler/wrap.js';
+import { log } from '../compiler/log.js';
 
 // Parse arguments
 const args = process.argv.slice(2);
@@ -29,8 +30,24 @@ 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' });
+let compiler = process.env.CC;
+if (!compiler) {
+  try {
+    execSync('musl-gcc --version');
+    compiler = 'musl-gcc';
+  } catch {
+    // todo: this should be in future docs somewhere and linked instead
+    log.warning('lambda', `musl-gcc is recommended for Lambda as it noticably improves deployed performance. install it or explicitly specify a compiler via CC to hide this warning. defaulting to gcc.`);
+    compiler = 'gcc';
+  }
+}
+
+if (Prefs.d) {
+  execSync(`${compiler} -lm -O0 -g -flto -march=x86-64-v3 -o ${binaryPath} ${cPath}`, { stdio: 'inherit' });
+} else {
+  execSync(`${compiler} ${compiler === 'musl-gcc' ? '-static' : ''} -lm -O3 -fomit-frame-pointer -s -flto -march=x86-64-v3 -ffunction-sections -fdata-sections -Wl,--gc-sections -o ${binaryPath} ${cPath}`, { stdio: 'inherit' });
+  execSync(`strip ${binaryPath}`, { stdio: 'inherit' });
+}
 
 try {
   execSync(`zip -r "${outputZip}" ${binaryPath}`, { stdio: 'inherit' });