fix regressions double implicit casting return ptr

src/analyze.cpp

@@ -9396,6 +9396,9 @@ static void dump_value_indent(ZigValue *val, int indent) {
         case ZigTypeIdUnreachable:
             fprintf(stderr, "<unreachable>\n");
             return;
+        case ZigTypeIdUndefined:
+            fprintf(stderr, "<undefined>\n");
+            return;
         case ZigTypeIdVoid:
             fprintf(stderr, "<{}>\n");
             return;
@@ -9405,11 +9408,16 @@ static void dump_value_indent(ZigValue *val, int indent) {
         case ZigTypeIdBool:
             fprintf(stderr, "<%s>\n", val->data.x_bool ? "true" : "false");
             return;
-        case ZigTypeIdComptimeFloat:
         case ZigTypeIdComptimeInt:
-        case ZigTypeIdInt:
+        case ZigTypeIdInt: {
+            Buf *tmp_buf = buf_alloc();
+            bigint_append_buf(tmp_buf, &val->data.x_bigint, 10);
+            fprintf(stderr, "<%s>\n", buf_ptr(tmp_buf));
+            buf_destroy(tmp_buf);
+            return;
+        }
+        case ZigTypeIdComptimeFloat:
         case ZigTypeIdFloat:
-        case ZigTypeIdUndefined:
             fprintf(stderr, "<TODO dump number>\n");
             return;
 
@@ -9458,6 +9466,23 @@ static void dump_value_indent(ZigValue *val, int indent) {
                     fprintf(stderr, "<ref\n");
                     dump_value_indent(val->data.x_ptr.data.ref.pointee, indent + 1);
                     break;
+                case ConstPtrSpecialBaseStruct: {
+                    ZigValue *struct_val = val->data.x_ptr.data.base_struct.struct_val;
+                    size_t field_index = val->data.x_ptr.data.base_struct.field_index;
+                    fprintf(stderr, "<struct %p field %zu\n", struct_val, field_index);
+                    if (struct_val != nullptr) {
+                        ZigValue *field_val = struct_val->data.x_struct.fields[field_index];
+                        if (field_val != nullptr) {
+                            dump_value_indent(field_val, indent + 1);
+                        } else {
+                            for (int i = 0; i < indent; i += 1) {
+                                fprintf(stderr, " ");
+                            }
+                            fprintf(stderr, "(invalid null field)\n");
+                        }
+                    }
+                    break;
+                }
                 default:
                     fprintf(stderr, "TODO dump more pointer things\n");
             }

src/codegen.cpp

@@ -20,6 +20,7 @@
 #include "zig_llvm.h"
 #include "userland.h"
 #include "dump_analysis.hpp"
+#include "softfloat.hpp"
 
 #include <stdio.h>
 #include <errno.h>

src/ir.cpp

@@ -12313,8 +12313,8 @@ static IrInstruction *ir_analyze_err_wrap_payload(IrAnalyze *ira, IrInstruction
         if (type_is_invalid(casted_payload->value->type))
             return ira->codegen->invalid_instruction;
 
-        ZigValue *val = ir_resolve_const(ira, casted_payload, UndefBad);
-        if (!val)
+        ZigValue *val = ir_resolve_const(ira, casted_payload, UndefOk);
+        if (val == nullptr)
             return ira->codegen->invalid_instruction;
 
         ZigValue *err_set_val = create_const_vals(1);
@@ -17519,6 +17519,7 @@ static IrInstruction *ir_resolve_result(IrAnalyze *ira, IrInstruction *suspend_s
     {
         result_loc_pass1 = no_result_loc();
     }
+    bool was_written = result_loc_pass1->written;
     IrInstruction *result_loc = ir_resolve_result_raw(ira, suspend_source_instr, result_loc_pass1, value_type,
             value, force_runtime, allow_discard);
     if (result_loc == nullptr || (instr_is_unreachable(result_loc) || type_is_invalid(result_loc->value->type)))
@@ -17596,6 +17597,9 @@ static IrInstruction *ir_resolve_result(IrAnalyze *ira, IrInstruction *suspend_s
         result_loc_pass1->resolved_loc = result_loc;
     }
 
+    if (was_written) {
+        return result_loc;
+    }
 
     ir_assert(result_loc->value->type->id == ZigTypeIdPointer, suspend_source_instr);
     ZigType *actual_elem_type = result_loc->value->type->data.pointer.child_type;
@@ -18242,13 +18246,6 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstruction *source_i
                 return ira->codegen->invalid_instruction;
         }
 
-        if (fn_proto_node->data.fn_proto.is_var_args) {
-            ir_add_error(ira, source_instr,
-                    buf_sprintf("compiler bug: unable to call var args function at compile time. https://github.com/ziglang/zig/issues/313"));
-            return ira->codegen->invalid_instruction;
-        }
-
-
         for (size_t call_i = 0; call_i < args_len; call_i += 1) {
             IrInstruction *old_arg = args_ptr[call_i];
 

src/softfloat.hpp

@@ -12,4 +12,21 @@ extern "C" {
 #include "softfloat.h"
 }
 
+static inline float16_t zig_double_to_f16(double x) {
+    float64_t y;
+    static_assert(sizeof(x) == sizeof(y), "");
+    memcpy(&y, &x, sizeof(x));
+    return f64_to_f16(y);
+}
+
+
+// Return value is safe to coerce to float even when |x| is NaN or Infinity.
+static inline double zig_f16_to_double(float16_t x) {
+    float64_t y = f16_to_f64(x);
+    double z;
+    static_assert(sizeof(y) == sizeof(z), "");
+    memcpy(&z, &y, sizeof(y));
+    return z;
+}
+
 #endif

src/util.hpp

@@ -38,6 +38,8 @@
 
 #if defined(__MINGW32__) || defined(__MINGW64__)
 #define BREAKPOINT __debugbreak()
+#elif defined(__i386__) || defined(__x86_64__)
+#define BREAKPOINT __asm__ volatile("int $0x03");
 #elif defined(__clang__)
 #define BREAKPOINT __builtin_debugtrap()
 #elif defined(__GNUC__)
@@ -49,8 +51,6 @@
 
 #endif
 
-#include "softfloat.hpp"
-
 ATTRIBUTE_COLD
 ATTRIBUTE_NORETURN
 ATTRIBUTE_PRINTF(1, 2)
@@ -244,23 +244,6 @@ static inline uint8_t log2_u64(uint64_t x) {
     return (63 - clzll(x));
 }
 
-static inline float16_t zig_double_to_f16(double x) {
-    float64_t y;
-    static_assert(sizeof(x) == sizeof(y), "");
-    memcpy(&y, &x, sizeof(x));
-    return f64_to_f16(y);
-}
-
-
-// Return value is safe to coerce to float even when |x| is NaN or Infinity.
-static inline double zig_f16_to_double(float16_t x) {
-    float64_t y = f16_to_f64(x);
-    double z;
-    static_assert(sizeof(y) == sizeof(z), "");
-    memcpy(&z, &y, sizeof(y));
-    return z;
-}
-
 void zig_pretty_print_bytes(FILE *f, double n);
 
 template<typename T>

test/stage1/behavior.zig

@@ -59,7 +59,7 @@ comptime {
     _ = @import("behavior/defer.zig");
     _ = @import("behavior/enum.zig");
     _ = @import("behavior/enum_with_members.zig");
-    //_ = @import("behavior/error.zig");
+    _ = @import("behavior/error.zig");
     _ = @import("behavior/eval.zig");
     _ = @import("behavior/field_parent_ptr.zig");
     _ = @import("behavior/floatop.zig");