clarify comment

Author: spiessimon

backend/amd64/emit.ml

@@ -1689,7 +1689,10 @@ let emit_instr ~first ~fallthrough i =
       (* +0.0 *)
       I.xorpd (res i 0) (res i 0)
     | _ ->
-      (* float32 constants still take up 8 bytes; we load the lower half. *)
+      (* float32 constants take up 8 bytes when we emit them with
+         [float_literal] (see the conversion from int32 to int64 below). Thus,
+         we load the lower half. Note that this is different from Cmm 32-bit
+         floats ([Csingle]), which are emitted as 4-byte constants. *)
       let lbl = add_float_constant (Int64.of_int32 f) in
       I.movss (mem64_rip REAL4 (emit_label lbl)) (res i 0))
   | Lop (Const_float f) -> (

backend/arm64/emit.ml

@@ -745,8 +745,11 @@ let vec128_literals = ref ([] : (Cmm.vec128_bits * L.t) list)
 let add_literal p f =
   try List.assoc f !p
   with Not_found ->
-    (* CR sspies: Should the literals really be in the text section? They are
-       currently emitted at the end of a function in the text section. *)
+    (* CR sspies: The [Text] section here is incorrect. We should be in the
+       respective section of the literal type (i.e., 16 or 8 bytes). The code
+       below uses the [Text] section, because that is the section that we are in
+       when we emit literals in the function body. Only macOS currently switches
+       to a dedicated section. *)
     let lbl = L.create Text in
     p := (f, lbl) :: !p;
     lbl
@@ -765,6 +768,8 @@ let emit_literals p align emit_literal =
         ~names:["__TEXT,__literal" ^ Int.to_string align]
         ~flags:None
         ~args:[Int.to_string align ^ "byte_literals"];
+      (* CR sspies: The following section is incorrect. We are in a data section
+         here. Fix this when cleaning up the section mechanism. *)
       D.unsafe_set_interal_section_ref Text);
     D.align ~bytes:align;
     List.iter emit_literal !p;
@@ -1415,9 +1420,10 @@ let emit_instr i =
       DSL.ins I.FMOV
         [| DSL.emit_reg i.res.(0); DSL.imm_float (Int32.float_of_bits f) |]
     else
-      (* float32 constants still take up 8 bytes; we load the lower half. *)
-      (* CR sspies: Check whether this is 32-bit or 64-bit. There is currently
-         ambiguity about this. *)
+      (* float32 constants take up 8 bytes when we emit them with
+         [float_literal] (see the conversion from int32 to int64 below). Thus,
+         we load the lower half. Note that this is different from Cmm 32-bit
+         floats ([Csingle]), which are emitted as 4-byte constants. *)
       let lbl = float_literal (Int64.of_int32 f) in
       emit_load_literal i.res.(0) lbl
   | Lop (Const_float f) ->
@@ -2202,7 +2208,7 @@ let end_assembly () =
       (* [efa_16] is [D.uint16 (Numbers.Uint16.of_int_exn n)] in
          mshinwell/ocaml#gdb-names-gpr x86 emitter *)
       efa_16 = (fun n -> D.uint16 (Numbers.Uint16.of_nonnegative_int_exn n));
-      (* [efa_16] is [D.uint32 (Numbers.Uint32.of_int32 n)] in
+      (* [efa_32] is [D.uint32 (Numbers.Uint32.of_int32 n)] in
          mshinwell/ocaml#gdb-names-gpr x86 emitter *)
       (* CR sspies: for some reason, we can get negative numbers here *)
       efa_32 = (fun n -> D.int32 n);