Allow float division in compile-time constants (#1263)

Author: Akuli

compiler/builders/any_builder.jou

@@ -305,14 +305,14 @@ class AnyBuilder:
         return result
 
     @public
-    def float_or_double(self, t: Type*, string: byte*) -> AnyBuilderValue:
+    def float_or_double(self, t: Type*, dbl: double) -> AnyBuilderValue:
         result = AnyBuilderValue{}
         if self.lbuilder != NULL:
-            result.lvalue = self.lbuilder.float_or_double(t, string)
+            result.lvalue = self.lbuilder.float_or_double(t, dbl)
         if self.ubuilder != NULL:
-            result.uvalue = self.ubuilder.float_or_double(t, string)
+            result.uvalue = self.ubuilder.float_or_double(t, dbl)
         if self.hbuilder != NULL:
-            result.hvalue = self.hbuilder.float_or_double(t, string)
+            result.hvalue = self.hbuilder.float_or_double(t, dbl)
         return result
 
     @public

compiler/builders/ast_to_builder.jou

@@ -396,7 +396,7 @@ class AstToBuilder:
             case ConstantKind.Bool:
                 return self.builder.boolean(constant.boolean)
             case ConstantKind.Float | ConstantKind.Double:
-                return self.builder.float_or_double(constant.get_type(), constant.float_or_double_text)
+                return self.builder.float_or_double(constant.get_type(), constant.float_or_double_value)
             case ConstantKind.Null:
                 return self.builder.zero_of_type(void_ptr_type())
             case ConstantKind.EnumMember:

compiler/builders/hash_builder.jou

@@ -247,9 +247,9 @@ class HBuilder:
         return self.new_value(t)
 
     @public
-    def float_or_double(self, t: Type*, string: byte*) -> HBuilderValue:
+    def float_or_double(self, t: Type*, dbl: double) -> HBuilderValue:
         self.hash.add_string("float_or_double")
-        self.hash.add_string(string)
+        self.hash.add_bytes(&dbl as byte*, sizeof(dbl))
         return self.new_value(t)
 
     @public

compiler/builders/llvm_builder.jou

@@ -603,11 +603,11 @@ class LBuilder:
         }
 
     @public
-    def float_or_double(self, t: Type*, string: byte*) -> LBuilderValue:
+    def float_or_double(self, t: Type*, dbl: double) -> LBuilderValue:
         assert t.kind == TypeKind.FloatingPoint
         return LBuilderValue{
             type = t,
-            llvm_value = LLVMConstRealOfString(type_to_llvm(self.state, t), string)
+            llvm_value = LLVMConstReal(type_to_llvm(self.state, t), dbl)
         }
 
     @public

compiler/builders/uvg_builder.jou

@@ -156,7 +156,7 @@ class UBuilder:
         return ANONYMOUS_VALUE_ID
 
     @public
-    def float_or_double(self, t: Type*, string: byte*) -> int:
+    def float_or_double(self, t: Type*, dbl: double) -> int:
         return ANONYMOUS_VALUE_ID
 
     @public

compiler/constants.jou

@@ -8,6 +8,10 @@ import "stdlib/mem.jou"
 import "./types.jou"
 
 
+# TODO: this function doesn't belong here
+declare atof(string: byte*) -> double
+
+
 def print_string(s: byte*) -> None:
     putchar('"')
     for i = 0; s[i] != '\0'; i++:
@@ -47,14 +51,28 @@ class EnumMemberConstant:
     enumtype: Type*
     memberidx: int
 
+# Needed only for debugging
+def print_double(n: double) -> None:
+    # 17 significant digits is enough to print any double, but it's too
+    # much for some doubles. For example, with 17 significant digits, 3.14
+    # becomes 3.1400000000000001.
+    #
+    # The same logic is in stdlib/json.jou at the time of writing this.
+    buf: byte[64] = ""
+    snprintf(buf, sizeof(buf), "%.16g", n)
+    if atof(buf) != n:
+        snprintf(buf, sizeof(buf), "%.17g", n)
+    printf("%s", buf)
+
+
 @public
 class Constant:
     kind: ConstantKind
     union:
         integer: IntegerConstant
         pointer_string: byte*
         array_of_bytes: List[byte]  # may contain zero bytes
-        float_or_double_text: byte[100]  # convenient because LLVM wants a string anyway
+        float_or_double_value: double
         boolean: bool
         enum_member: EnumMemberConstant
         array_elements: List[Constant]
@@ -70,9 +88,13 @@ class Constant:
                 else:
                     printf("False\n")
             case ConstantKind.Float:
-                printf("float %s\n", self.float_or_double_text)
+                printf("float ")
+                print_double(self.float_or_double_value)
+                printf("\n")
             case ConstantKind.Double:
-                printf("double %s\n", self.float_or_double_text)
+                printf("double ")
+                print_double(self.float_or_double_value)
+                printf("\n")
             case ConstantKind.Integer:
                 if self.integer.is_signed:
                     signed_or_unsigned = "signed"

compiler/evaluate.jou

@@ -210,20 +210,36 @@ def evaluate_constant_expression(jou_file: JouFile*, expr: AstExpression*, resul
                     result.integer.value *= -1
                     return True
                 case TypeKind.FloatingPoint:
-                    old_string: byte[100] = result.float_or_double_text
-                    if old_string[0] == '-':
-                        # Remove minus sign in beginning: -(-1.0) becomes 1.0
-                        strcpy(result.float_or_double_text, &old_string[1])
-                        return True
-                    elif strlen(old_string) + 1 < sizeof(result.float_or_double_text):
-                        # Add minus to beginning
-                        sprintf(result.float_or_double_text, "-%s", old_string)
-                        return True
-                    else:
-                        return False
+                    result.float_or_double_value *= -1
+                    return True
                 case _:
                     return False
 
+        # Evaluate float division in some very limited cases.
+        # Mostly for defining "INF = 1.0 / 0.0" and similar constants.
+        #
+        # Note: This evaluates the division on the computer that is compiling,
+        # not on the target. So if floating point works differently on the
+        # target computer, this may be off. Currently that is not the case with
+        # any of our supported compilation targets.
+        case AstExpressionKind.Div:
+            if type_hint != float_type() and type_hint != double_type():
+                return False
+
+            lhs_rhs: Constant[2]
+            for i = 0; i < 2; i++:
+                if not evaluate_constant_expression(jou_file, &expr.operands[i], &lhs_rhs[i], type_hint):
+                    return False
+                if lhs_rhs[i].get_type() != type_hint:
+                    return False
+
+            assert lhs_rhs[0].kind == lhs_rhs[1].kind
+            *result = Constant{
+                kind = lhs_rhs[0].kind,
+                float_or_double_value = lhs_rhs[0].float_or_double_value / lhs_rhs[1].float_or_double_value,
+            }
+            return True
+
         case AstExpressionKind.Array:
             if type_hint != NULL and type_hint.kind == TypeKind.Array:
                 item_type_hint = type_hint.array.item_type

compiler/llvm.jou

@@ -355,6 +355,8 @@ declare LLVMGetUndef(Ty: LLVMType*) -> LLVMValue*
 @public
 declare LLVMConstInt(IntTy: LLVMType*, N: int64, SignExtend: int) -> LLVMValue*
 @public
+declare LLVMConstReal(RealTy: LLVMType*, N: double) -> LLVMValue*
+@public
 declare LLVMConstRealOfString(RealTy: LLVMType*, Text: byte*) -> LLVMValue*
 @public
 declare LLVMConstStringInContext(C: LLVMContext*, Str: byte*, Length: uint32, DontNullTerminate: int) -> LLVMValue*

compiler/parser.jou

@@ -15,6 +15,10 @@ import "./constants.jou"
 import "./types.jou"
 
 
+# TODO: this function doesn't belong here
+declare atof(string: byte*) -> double
+
+
 # arity = number of operands, e.g. 2 for a binary operator such as "+"
 #
 # This cannot be used for ++ and --, because with them we can't know the kind from
@@ -685,10 +689,10 @@ class Parser:
                 expr.constant = int_constant(uint_type(8), (self.tokens++).integer_value as int64)
             case TokenKind.Float:
                 expr.kind = AstExpressionKind.Constant
-                expr.constant = Constant{kind = ConstantKind.Float, float_or_double_text = (self.tokens++).short_string}
+                expr.constant = Constant{kind = ConstantKind.Float, float_or_double_value = atof((self.tokens++).short_string)}
             case TokenKind.Double:
                 expr.kind = AstExpressionKind.Constant
-                expr.constant = Constant{kind = ConstantKind.Double, float_or_double_text = (self.tokens++).short_string}
+                expr.constant = Constant{kind = ConstantKind.Double, float_or_double_value = atof((self.tokens++).short_string)}
             case TokenKind.String:
                 expr.kind = AstExpressionKind.Constant
                 expr.constant = Constant{kind = ConstantKind.PointerString, pointer_string = strdup((self.tokens++).long_string)}

tests/should_succeed/math_test.jou

@@ -1,6 +1,18 @@
 import "stdlib/math.jou"
 import "stdlib/io.jou"
 
+# TODO: move these to stdlib/math.jou
+#
+# Here are some more readable ways to construct non-finite values. Note that
+# there are multiple different NaN values (see also: nan boxing), and the NaN
+# constructed here is just one of them.
+#
+# Like M_PI and M_E, these are doubles. Use "as float" as needed.
+@public
+const INFINITY: double = 1.0 / 0.0
+@public
+const NAN: double = 0.0 / 0.0
+
 def main() -> int:
     printf("%f\n", M_PI)  # Output: 3.141593
     printf("%d\n", M_PI == acos(-1))  # Output: 1
@@ -18,23 +30,41 @@ def main() -> int:
     printf("%f\n", fmax(1.2, 3.4))  # Output: 3.400000
     printf("%f\n", fmaxf(1.2 as float, 3.4 as float))  # Output: 3.400000
 
-    test_doubles = [123.0, -123.0, 1.0 / 0.0, -1.0 / 0.0, 0.0 / 0.0, -0.0 / 0.0]
+    test_doubles = [
+        0.0, -0.0, 123.0, -123.0,
+        # Parentheses are intentionally a bit weirdly here. It shouldn't matter
+        # how they are and I want to test that.
+        INFINITY, 1.0/0.0, -INFINITY, (-1.0)/0.0,
+        NAN, 0.0/0.0, -NAN, 0.0/(-0.0),
+    ]
 
     # Output: 1 0 0
     # Output: 1 0 0
+    # Output: 1 0 0
+    # Output: 1 0 0
+    # Output: 0 1 0
     # Output: 0 1 0
     # Output: 0 1 0
+    # Output: 0 1 0
+    # Output: 0 0 1
+    # Output: 0 0 1
     # Output: 0 0 1
     # Output: 0 0 1
     for d = &test_doubles[0]; d < &test_doubles[array_count(test_doubles)]; d++:
         printf("%d %d %d\n", isfinite(*d), isinf(*d), isnan(*d))
 
     # Output: 1 0 0
     # Output: 1 0 0
+    # Output: 1 0 0
+    # Output: 1 0 0
+    # Output: 0 1 0
+    # Output: 0 1 0
     # Output: 0 1 0
     # Output: 0 1 0
     # Output: 0 0 1
     # Output: 0 0 1
+    # Output: 0 0 1
+    # Output: 0 0 1
     for d = &test_doubles[0]; d < &test_doubles[array_count(test_doubles)]; d++:
         printf("%d %d %d\n", isfinite(*d as float), isinf(*d as float), isnan(*d as float))
 
@@ -106,4 +136,10 @@ def main() -> int:
     printf("%f\n", erf(2))  # Output: 0.995322
     printf("%f\n", erff(2))  # Output: 0.995322
 
+    # This wouldn't work if INFINITY is a float. Then the compiler would infer
+    # that my_inf is a float and refuse to assign a double to it.
+    my_inf = INFINITY
+    my_inf = 12.34
+    printf("%f\n", my_inf)  # Output: 12.340000
+
     return 0