Merge pull request #3236 from jepler/firmware-size-gemma-trinket

Firmware size savings

12 files changed, 74 insertions, 65 deletions

diff --git a/py/obj.c b/py/obj.c
index 7644b5de8..0cff2f1a4 100644
--- a/py/obj.c
+++ b/py/obj.c
@@ -58,7 +58,7 @@ mp_obj_type_t *mp_obj_get_type(mp_const_obj_t o_in) {
 }
 
 const char *mp_obj_get_type_str(mp_const_obj_t o_in) {
-    return qstr_str(mp_obj_get_type(o_in)->name);
+    return qstr_str(mp_obj_get_type_qstr(o_in));
 }
 
 void mp_obj_print_helper(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t kind) {
@@ -260,10 +260,10 @@ mp_int_t mp_obj_get_int(mp_const_obj_t arg) {
         return mp_obj_int_get_checked(arg);
     } else {
         if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError(translate("can't convert to int"));
+            mp_raise_TypeError_varg(translate("can't convert to %q"), MP_QSTR_int);
         } else {
             mp_raise_TypeError_varg(
-                translate("can't convert %s to int"), mp_obj_get_type_str(arg));
+                translate("can't convert %q to %q"), mp_obj_get_type_qstr(arg), MP_QSTR_int);
         }
     }
 }
@@ -323,10 +323,10 @@ mp_float_t mp_obj_get_float(mp_obj_t arg) {
 
     if (!mp_obj_get_float_maybe(arg, &val)) {
         if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError(translate("can't convert to float"));
+            mp_raise_TypeError_varg(translate("can't convert to %q"), MP_QSTR_float);
         } else {
             mp_raise_TypeError_varg(
-                translate("can't convert %s to float"), mp_obj_get_type_str(arg));
+                translate("can't convert %q to %q"), mp_obj_get_type_qstr(arg), MP_QSTR_float);
         }
     }
 
@@ -356,10 +356,10 @@ void mp_obj_get_complex(mp_obj_t arg, mp_float_t *real, mp_float_t *imag) {
         mp_obj_complex_get(arg, real, imag);
     } else {
         if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
-            mp_raise_TypeError(translate("can't convert to complex"));
+            mp_raise_TypeError_varg(translate("can't convert to %q"), MP_QSTR_complex);
         } else {
             mp_raise_TypeError_varg(
-                translate("can't convert %s to complex"), mp_obj_get_type_str(arg));
+                translate("can't convert %q to %q"), mp_obj_get_type_qstr(arg), MP_QSTR_complex);
         }
     }
 }
@@ -377,7 +377,7 @@ void mp_obj_get_array(mp_obj_t o, size_t *len, mp_obj_t **items) {
             mp_raise_TypeError(translate("expected tuple/list"));
         } else {
             mp_raise_TypeError_varg(
-                translate("object '%s' is not a tuple or list"), mp_obj_get_type_str(o));
+                translate("object '%q' is not a tuple or list"), mp_obj_get_type_qstr(o));
         }
     }
 }
@@ -406,8 +406,8 @@ size_t mp_get_index(const mp_obj_type_t *type, size_t len, mp_obj_t index, bool
             mp_raise_TypeError(translate("indices must be integers"));
         } else {
             mp_raise_TypeError_varg(
-                translate("%q indices must be integers, not %s"),
-                type->name, mp_obj_get_type_str(index));
+                translate("%q indices must be integers, not %q"),
+                type->name, mp_obj_get_type_qstr(index));
         }
     }
 
@@ -461,7 +461,7 @@ mp_obj_t mp_obj_len(mp_obj_t o_in) {
             mp_raise_TypeError(translate("object has no len"));
         } else {
             mp_raise_TypeError_varg(
-                translate("object of type '%s' has no len()"), mp_obj_get_type_str(o_in));
+                translate("object of type '%q' has no len()"), mp_obj_get_type_qstr(o_in));
         }
     } else {
         return len;
@@ -504,21 +504,21 @@ mp_obj_t mp_obj_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
             mp_raise_TypeError(translate("object does not support item deletion"));
         } else {
             mp_raise_TypeError_varg(
-                translate("'%s' object does not support item deletion"), mp_obj_get_type_str(base));
+                translate("'%q' object does not support item deletion"), mp_obj_get_type_qstr(base));
         }
     } else if (value == MP_OBJ_SENTINEL) {
         if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
             mp_raise_TypeError(translate("object is not subscriptable"));
         } else {
             mp_raise_TypeError_varg(
-                translate("'%s' object is not subscriptable"), mp_obj_get_type_str(base));
+                translate("'%q' object is not subscriptable"), mp_obj_get_type_qstr(base));
         }
     } else {
         if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
             mp_raise_TypeError(translate("object does not support item assignment"));
         } else {
             mp_raise_TypeError_varg(
-                translate("'%s' object does not support item assignment"), mp_obj_get_type_str(base));
+                translate("'%q' object does not support item assignment"), mp_obj_get_type_qstr(base));
         }
     }
 }
diff --git a/py/obj.h b/py/obj.h
index e603d4a49..e9d867f77 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -680,6 +680,7 @@ mp_obj_t mp_obj_new_memoryview(byte typecode, size_t nitems, void *items);
 
 mp_obj_type_t *mp_obj_get_type(mp_const_obj_t o_in);
 const char *mp_obj_get_type_str(mp_const_obj_t o_in);
+#define mp_obj_get_type_qstr(o_in) (mp_obj_get_type((o_in))->name)
 bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo); // arguments should be type objects
 mp_obj_t mp_instance_cast_to_native_base(mp_obj_t self_in, mp_const_obj_t native_type);
 
diff --git a/py/objdict.c b/py/objdict.c
index 39169fe1a..63fd86f35 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -313,7 +313,7 @@ STATIC mp_obj_t dict_popitem(mp_obj_t self_in) {
     size_t cur = 0;
     mp_map_elem_t *next = dict_iter_next(self, &cur);
     if (next == NULL) {
-        mp_raise_msg(&mp_type_KeyError, translate("popitem(): dictionary is empty"));
+        mp_raise_msg_varg(&mp_type_KeyError, translate("pop from empty %q"), MP_QSTR_dict);
     }
     self->map.used--;
     mp_obj_t items[] = {next->key, next->value};
diff --git a/py/objint.c b/py/objint.c
index 82f5aadd1..b12bb3995 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -141,9 +141,9 @@ STATIC mp_fp_as_int_class_t mp_classify_fp_as_int(mp_float_t val) {
 mp_obj_t mp_obj_new_int_from_float(mp_float_t val) {
     int cl = fpclassify(val);
     if (cl == FP_INFINITE) {
-        nlr_raise(mp_obj_new_exception_msg(&mp_type_OverflowError, translate("can't convert inf to int")));
+        mp_raise_OverflowError_varg(translate("can't convert %q to %q"), MP_QSTR_inf, MP_QSTR_int);
     } else if (cl == FP_NAN) {
-        mp_raise_ValueError(translate("can't convert NaN to int"));
+        mp_raise_ValueError_varg(translate("can't convert %q to %q"), MP_QSTR_NaN, MP_QSTR_int);
     } else {
         mp_fp_as_int_class_t icl = mp_classify_fp_as_int(val);
         if (icl == MP_FP_CLASS_FIT_SMALLINT) {
diff --git a/py/objlist.c b/py/objlist.c
index 9242020d4..51ec920be 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -274,7 +274,7 @@ STATIC mp_obj_t list_pop(size_t n_args, const mp_obj_t *args) {
     mp_check_self(MP_OBJ_IS_TYPE(args[0], &mp_type_list));
     mp_obj_list_t *self = mp_instance_cast_to_native_base(args[0], &mp_type_list);
     if (self->len == 0) {
-        mp_raise_IndexError(translate("pop from empty list"));
+        mp_raise_IndexError_varg(translate("pop from empty %q"), MP_QSTR_list);
     }
     size_t index = mp_get_index(self->base.type, self->len, n_args == 1 ? MP_OBJ_NEW_SMALL_INT(-1) : args[1], false);
     mp_obj_t ret = self->items[index];
diff --git a/py/objset.c b/py/objset.c
index d986c6dda..b8f0f07ed 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -368,7 +368,7 @@ STATIC mp_obj_t set_pop(mp_obj_t self_in) {
     mp_obj_set_t *self = MP_OBJ_TO_PTR(self_in);
     mp_obj_t obj = mp_set_remove_first(&self->set);
     if (obj == MP_OBJ_NULL) {
-        mp_raise_msg(&mp_type_KeyError, translate("pop from an empty set"));
+        mp_raise_msg_varg(&mp_type_KeyError, translate("pop from empty %q"), MP_QSTR_set);
     }
     return obj;
 }
diff --git a/py/objstr.c b/py/objstr.c
index 5e0c6fdfa..edb562df2 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -1076,7 +1076,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                 }
                 field_name = str_to_int(field_name, field_name_top, &index);
                 if ((uint)index >= n_args - 1) {
-                    mp_raise_IndexError(translate("tuple index out of range"));
+                    mp_raise_IndexError_varg(translate("%q index out of range"), MP_QSTR_tuple);
                 }
                 arg = args[index + 1];
                 *arg_i = -1;
@@ -1104,7 +1104,7 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                 }
             }
             if ((uint)*arg_i >= n_args - 1) {
-                mp_raise_IndexError(translate("tuple index out of range"));
+                mp_raise_IndexError_varg(translate("%q index out of range"), MP_QSTR_tuple);
             }
             arg = args[(*arg_i) + 1];
             (*arg_i)++;
@@ -1280,8 +1280,8 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                         terse_str_format_value_error();
                     } else {
                         mp_raise_ValueError_varg(
-                            translate("unknown format code '%c' for object of type '%s'"),
-                            type, mp_obj_get_type_str(arg));
+                            translate("unknown format code '%c' for object of type '%q'"),
+                            type, mp_obj_get_type_qstr(arg));
                     }
             }
         }
@@ -1352,8 +1352,8 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                         terse_str_format_value_error();
                     } else {
                         mp_raise_ValueError_varg(
-                            translate("unknown format code '%c' for object of type '%s'"),
-                            type, mp_obj_get_type_str(arg));
+                            translate("unknown format code '%c' for object of type '%q'"),
+                            type, mp_obj_get_type_qstr(arg));
                     }
             }
         } else {
@@ -1388,8 +1388,8 @@ STATIC vstr_t mp_obj_str_format_helper(const char *str, const char *top, int *ar
                         terse_str_format_value_error();
                     } else {
                         mp_raise_ValueError_varg(
-                            translate("unknown format code '%c' for object of type '%s'"),
-                            type, mp_obj_get_type_str(arg));
+                            translate("unknown format code '%c' for object of type '%q'"),
+                            type, mp_obj_get_type_qstr(arg));
                     }
             }
         }
@@ -2133,7 +2133,7 @@ STATIC NORETURN void bad_implicit_conversion(mp_obj_t self_in) {
     if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
         mp_raise_TypeError(translate("can't convert to str implicitly"));
     } else {
-        const qstr src_name = mp_obj_get_type(self_in)->name;
+        const qstr src_name = mp_obj_get_type_qstr(self_in);
         nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_TypeError,
             translate("can't convert '%q' object to %q implicitly"),
             src_name, src_name == MP_QSTR_str ? MP_QSTR_bytes : MP_QSTR_str));
diff --git a/py/objstrunicode.c b/py/objstrunicode.c
index 351a67e91..50250abfa 100644
--- a/py/objstrunicode.c
+++ b/py/objstrunicode.c
@@ -151,7 +151,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
     if (MP_OBJ_IS_SMALL_INT(index)) {
         i = MP_OBJ_SMALL_INT_VALUE(index);
     } else if (!mp_obj_get_int_maybe(index, &i)) {
-        mp_raise_TypeError_varg(translate("string indices must be integers, not %s"), mp_obj_get_type_str(index));
+        mp_raise_TypeError_varg(translate("string indices must be integers, not %q"), mp_obj_get_type_qstr(index));
     }
     const byte *s, *top = self_data + self_len;
     if (i < 0)
@@ -162,7 +162,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
                 if (is_slice) {
                     return self_data;
                 }
-                mp_raise_IndexError(translate("string index out of range"));
+                mp_raise_IndexError_varg(translate("%q index out of range"), MP_QSTR_str);
             }
             if (!UTF8_IS_CONT(*s)) {
                 ++i;
@@ -181,7 +181,7 @@ const byte *str_index_to_ptr(const mp_obj_type_t *type, const byte *self_data, s
                 if (is_slice) {
                     return top;
                 }
-                mp_raise_IndexError(translate("string index out of range"));
+                mp_raise_IndexError_varg(translate("%q index out of range"), MP_QSTR_str);
             }
             // Then check completion
             if (i-- == 0) {
diff --git a/py/objtype.c b/py/objtype.c
index fd51ce36b..ccd014c33 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -193,7 +193,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
                 printf("mp_obj_class_lookup: Returning: ");
                 mp_obj_print(lookup->dest[0], PRINT_REPR); printf(" ");
                 // Don't try to repr() lookup->dest[1], as we can be called recursively
-                printf("<%s @%p>\n", mp_obj_get_type_str(lookup->dest[1]), lookup->dest[1]);
+                printf("<%q @%p>\n", mp_obj_get_type_qstr(lookup->dest[1]), lookup->dest[1]);
 #endif
                 return;
             }
@@ -285,7 +285,7 @@ STATIC void instance_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
     }
 
     // TODO: CPython prints fully-qualified type name
-    mp_printf(print, "<%s object at %p>", mp_obj_get_type_str(self_in), self);
+    mp_printf(print, "<%q object at %p>", mp_obj_get_type_qstr(self_in), self);
 }
 
 mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
@@ -376,8 +376,8 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, cons
             if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
                 mp_raise_TypeError(translate("__init__() should return None"));
             } else {
-                mp_raise_TypeError_varg(translate("__init__() should return None, not '%s'"),
-                    mp_obj_get_type_str(init_ret));
+                mp_raise_TypeError_varg(translate("__init__() should return None, not '%q'"),
+                    mp_obj_get_type_qstr(init_ret));
             }
         }
 
@@ -891,8 +891,8 @@ mp_obj_t mp_obj_instance_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
         if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
             mp_raise_TypeError(translate("object not callable"));
         } else {
-            mp_raise_TypeError_varg(translate("'%s' object is not callable"),
-                mp_obj_get_type_str(self_in));
+            mp_raise_TypeError_varg(translate("'%q' object is not callable"),
+                mp_obj_get_type_qstr(self_in));
         }
     }
     mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
diff --git a/py/proto.c b/py/proto.c
index e5053130b..e4da157f0 100644
--- a/py/proto.c
+++ b/py/proto.c
@@ -45,6 +45,6 @@ const void *mp_proto_get_or_throw(uint16_t name, mp_const_obj_t obj) {
     if (proto) {
         return proto;
     }
-    mp_raise_TypeError_varg(translate("'%s' object does not support '%q'"),
-        mp_obj_get_type_str(obj), name);
+    mp_raise_TypeError_varg(translate("'%q' object does not support '%q'"),
+        mp_obj_get_type_qstr(obj), name);
 }
diff --git a/py/runtime.c b/py/runtime.c
index 91ead1fba..f9ef7819d 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -279,8 +279,8 @@ mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) {
             mp_raise_TypeError(translate("unsupported type for operator"));
         } else {
             mp_raise_TypeError_varg(
-                translate("unsupported type for %q: '%s'"),
-                mp_unary_op_method_name[op], mp_obj_get_type_str(arg));
+                translate("unsupported type for %q: '%q'"),
+                mp_unary_op_method_name[op], mp_obj_get_type_qstr(arg));
         }
     }
 }
@@ -586,8 +586,8 @@ unsupported_op:
         mp_raise_TypeError(translate("unsupported type for operator"));
     } else {
         mp_raise_TypeError_varg(
-            translate("unsupported types for %q: '%s', '%s'"),
-            mp_binary_op_method_name[op], mp_obj_get_type_str(lhs), mp_obj_get_type_str(rhs));
+            translate("unsupported types for %q: '%q', '%q'"),
+            mp_binary_op_method_name[op], mp_obj_get_type_qstr(lhs), mp_obj_get_type_qstr(rhs));
     }
 
 zero_division:
@@ -627,7 +627,7 @@ mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, size_t n_args, size_t n_kw, cons
     if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
         mp_raise_TypeError(translate("object not callable"));
     } else {
-        mp_raise_TypeError_varg(translate("'%s' object is not callable"), mp_obj_get_type_str(fun_in));
+        mp_raise_TypeError_varg(translate("'%q' object is not callable"), mp_obj_get_type_qstr(fun_in));
     }
 }
 
@@ -1104,8 +1104,8 @@ void mp_load_method(mp_obj_t base, qstr attr, mp_obj_t *dest) {
                     ((mp_obj_type_t*)MP_OBJ_TO_PTR(base))->name, attr));
             } else {
                 nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
-                    translate("'%s' object has no attribute '%q'"),
-                    mp_obj_get_type_str(base), attr));
+                    translate("'%q' object has no attribute '%q'"),
+                    mp_obj_get_type_qstr(base), attr));
             }
         }
     }
@@ -1172,8 +1172,8 @@ void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
         mp_raise_AttributeError(translate("no such attribute"));
     } else {
         nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_AttributeError,
-            translate("'%s' object cannot assign attribute '%q'"),
-            mp_obj_get_type_str(base), attr));
+            translate("'%q' object cannot assign attribute '%q'"),
+            mp_obj_get_type_qstr(base), attr));
     }
 }
 
@@ -1213,7 +1213,7 @@ mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
         mp_raise_TypeError(translate("object not iterable"));
     } else {
         mp_raise_TypeError_varg(
-            translate("'%s' object is not iterable"), mp_obj_get_type_str(o_in));
+            translate("'%q' object is not iterable"), mp_obj_get_type_qstr(o_in));
     }
 }
 
@@ -1234,8 +1234,8 @@ mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
             if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
                 mp_raise_TypeError(translate("object not an iterator"));
             } else {
-                mp_raise_TypeError_varg(translate("'%s' object is not an iterator"),
-                    mp_obj_get_type_str(o_in));
+                mp_raise_TypeError_varg(translate("'%q' object is not an iterator"),
+                    mp_obj_get_type_qstr(o_in));
             }
         }
     }
@@ -1270,8 +1270,8 @@ mp_obj_t mp_iternext(mp_obj_t o_in) {
             if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
                 mp_raise_TypeError(translate("object not an iterator"));
             } else {
-                mp_raise_TypeError_varg(translate("'%s' object is not an iterator"),
-                    mp_obj_get_type_str(o_in));
+                mp_raise_TypeError_varg(translate("'%q' object is not an iterator"),
+                    mp_obj_get_type_qstr(o_in));
             }
         }
     }
@@ -1522,12 +1522,16 @@ NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const compressed_strin
     }
 }
 
+NORETURN void mp_raise_msg_vlist(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, va_list argptr) {
+    mp_obj_t exception = mp_obj_new_exception_msg_vlist(exc_type, fmt, argptr);
+    nlr_raise(exception);
+}
+
 NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, ...) {
     va_list argptr;
     va_start(argptr,fmt);
-    mp_obj_t exception = mp_obj_new_exception_msg_vlist(exc_type, fmt, argptr);
+    mp_raise_msg_vlist(exc_type, fmt, argptr);
     va_end(argptr);
-    nlr_raise(exception);
 }
 
 NORETURN void mp_raise_AttributeError(const compressed_string_t *msg) {
@@ -1546,6 +1550,13 @@ NORETURN void mp_raise_IndexError(const compressed_string_t *msg) {
     mp_raise_msg(&mp_type_IndexError, msg);
 }
 
+NORETURN void mp_raise_IndexError_varg(const compressed_string_t *fmt, ...) {
+    va_list argptr;
+    va_start(argptr,fmt);
+    mp_raise_msg_vlist(&mp_type_IndexError, fmt, argptr);
+    va_end(argptr);
+}
+
 NORETURN void mp_raise_ValueError(const compressed_string_t *msg) {
     mp_raise_msg(&mp_type_ValueError, msg);
 }
@@ -1553,9 +1564,8 @@ NORETURN void mp_raise_ValueError(const compressed_string_t *msg) {
 NORETURN void mp_raise_ValueError_varg(const compressed_string_t *fmt, ...) {
     va_list argptr;
     va_start(argptr,fmt);
-    mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_ValueError, fmt, argptr);
+    mp_raise_msg_vlist(&mp_type_ValueError, fmt, argptr);
     va_end(argptr);
-    nlr_raise(exception);
 }
 
 NORETURN void mp_raise_TypeError(const compressed_string_t *msg) {
@@ -1565,9 +1575,8 @@ NORETURN void mp_raise_TypeError(const compressed_string_t *msg) {
 NORETURN void mp_raise_TypeError_varg(const compressed_string_t *fmt, ...) {
     va_list argptr;
     va_start(argptr,fmt);
-    mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_TypeError, fmt, argptr);
+    mp_raise_msg_vlist(&mp_type_TypeError, fmt, argptr);
     va_end(argptr);
-    nlr_raise(exception);
 }
 
 NORETURN void mp_raise_OSError(int errno_) {
@@ -1589,9 +1598,8 @@ NORETURN void mp_raise_OSError_errno_str(int errno_, mp_obj_t str) {
 NORETURN void mp_raise_OSError_msg_varg(const compressed_string_t *fmt, ...) {
     va_list argptr;
     va_start(argptr,fmt);
-    mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_OSError, fmt, argptr);
+    mp_raise_msg_vlist(&mp_type_OSError, fmt, argptr);
     va_end(argptr);
-    nlr_raise(exception);
 }
 
 NORETURN void mp_raise_NotImplementedError(const compressed_string_t *msg) {
@@ -1601,17 +1609,15 @@ NORETURN void mp_raise_NotImplementedError(const compressed_string_t *msg) {
 NORETURN void mp_raise_NotImplementedError_varg(const compressed_string_t *fmt, ...) {
     va_list argptr;
     va_start(argptr,fmt);
-    mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_NotImplementedError, fmt, argptr);
+    mp_raise_msg_vlist(&mp_type_NotImplementedError, fmt, argptr);
     va_end(argptr);
-    nlr_raise(exception);
 }
 
 NORETURN void mp_raise_OverflowError_varg(const compressed_string_t *fmt, ...) {
     va_list argptr;
     va_start(argptr,fmt);
-    mp_obj_t exception = mp_obj_new_exception_msg_vlist(&mp_type_OverflowError, fmt, argptr);
+    mp_raise_msg_vlist(&mp_type_OverflowError, fmt, argptr);
     va_end(argptr);
-    nlr_raise(exception);
 }
 
 NORETURN void mp_raise_MpyError(const compressed_string_t *msg) {
diff --git a/py/runtime.h b/py/runtime.h
index d3a82333e..dbc04b94e 100644
--- a/py/runtime.h
+++ b/py/runtime.h
@@ -152,6 +152,7 @@ void mp_import_all(mp_obj_t module);
 
 NORETURN void mp_raise_msg(const mp_obj_type_t *exc_type, const compressed_string_t *msg);
 NORETURN void mp_raise_msg_varg(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, ...);
+NORETURN void mp_raise_msg_vlist(const mp_obj_type_t *exc_type, const compressed_string_t *fmt, va_list argptr);
 NORETURN void mp_raise_ValueError(const compressed_string_t *msg);
 NORETURN void mp_raise_ValueError_varg(const compressed_string_t *fmt, ...);
 NORETURN void mp_raise_TypeError(const compressed_string_t *msg);
@@ -160,6 +161,7 @@ NORETURN void mp_raise_AttributeError(const compressed_string_t *msg);
 NORETURN void mp_raise_RuntimeError(const compressed_string_t *msg);
 NORETURN void mp_raise_ImportError(const compressed_string_t *msg);
 NORETURN void mp_raise_IndexError(const compressed_string_t *msg);
+NORETURN void mp_raise_IndexError_varg(const compressed_string_t *msg, ...);
 NORETURN void mp_raise_OSError(int errno_);
 NORETURN void mp_raise_OSError_errno_str(int errno_, mp_obj_t str);
 NORETURN void mp_raise_OSError_msg(const compressed_string_t *msg);