Revive the hlc.agc (accurate GC) grade.

compiler/add_pred.m

@@ -620,8 +620,10 @@
     goal_info_set_nonlocals(NonLocals, GoalInfo0, GoalInfo1),
     ( if
         ModuleName = mercury_private_builtin_module,
-        % This predicate is incompatible with some backends.
-        Name = "store_at_ref_impure",
+        % These predicates are incompatible with some backends.
+        ( Name = "store_at_ref_impure"
+        ; Name = "store_at_field_offset_impure"
+        ),
         require_complete_switch [CompilationTarget]
         (
             ( CompilationTarget = target_java

compiler/builtin_ops.m

@@ -253,6 +253,14 @@
 :- type simple_code(T)
     --->    assign(T, simple_assigned_expr(T))
     ;       ref_assign(T, T)
+    ;       field_assign(T, T, T)
+            % field_assign(Cell, Offset, Value).
+            % Write Value into the heap cell pointed to by Cell, at the
+            % word offset given by Offset. The primary tag of Cell is
+            % stripped at the lowering site. Used by the LCMC pass under
+            % accurate GC, where capturing the address of a field would
+            % create an interior pointer that the collector cannot
+            % relocate.
     ;       test(simple_test_expr(T))
     ;       noop(list(T)).
 
@@ -412,6 +420,10 @@
         PredName = "store_at_ref_impure",
         ProcNum = 0, Args = [X, Y],
         Code = ref_assign(X, Y)
+    ;
+        PredName = "store_at_field_offset_impure",
+        ProcNum = 0, Args = [Cell, Offset, Value],
+        Code = field_assign(Cell, Offset, Value)
     ;
         PredName = "unsafe_type_cast", ProcNum = 0, Args = [X, Y],
         % Note that the code we generate for unsafe_type_cast

compiler/call_gen.m

@@ -713,6 +713,15 @@
             StoreInstr = llds_instr(assign(mem_ref(AddrRval), ValueRval), ""),
             StoreCode = singleton(StoreInstr),
             Code = AddrVarCode ++ ValueVarCode ++ StoreCode
+        ;
+            SimpleCode = field_assign(CellVar, OffsetVar, ValueVar),
+            produce_variable(CellVar, CellVarCode, CellRval, !CLD),
+            produce_variable(OffsetVar, OffsetVarCode, OffsetRval, !CLD),
+            produce_variable(ValueVar, ValueVarCode, ValueRval, !CLD),
+            FieldLval = field(no, CellRval, OffsetRval),
+            StoreInstr = llds_instr(assign(FieldLval, ValueRval), ""),
+            StoreCode = singleton(StoreInstr),
+            Code = CellVarCode ++ OffsetVarCode ++ ValueVarCode ++ StoreCode
         ;
             SimpleCode = test(_),
             unexpected($pred, "malformed model_det builtin predicate")
@@ -737,6 +746,9 @@
         ;
             SimpleCode = ref_assign(_, _),
             unexpected($pred, "malformed model_semi builtin predicate")
+        ;
+            SimpleCode = field_assign(_, _, _),
+            unexpected($pred, "malformed model_semi builtin predicate")
         ;
             SimpleCode = noop(_),
             unexpected($pred, "malformed model_semi builtin predicate")

compiler/handle_options.m

@@ -691,15 +691,25 @@
         OT_OptUnusedArgsIntermod = do_not_opt_unused_args_intermod
     ),
 
-    % XXX With accurate gc, we need to disable optimize-constructor-last-call
-    % as currently the collector (and tracing code generator) knows neither
-    % about the pre-constructed data structures nor the references into them
-    % that this optimisation uses.
+    % LCMC under accurate GC needs the cell-and-offset capture that
+    % lco.m's lci_use_field_path branch implements: the original LLD
+    % store_at_ref_type pointer is an interior pointer into a heap cell
+    % and the AGC collector cannot relocate it when the cell is
+    % evacuated. The high-level-data path passes the parent cell as a
+    % partial-inst term, so it is already safe under AGC. The low-level
+    % MLDS path uses the new store_at_field_offset_impure builtin to
+    % keep the cell pointer GC-traceable while still landing the field
+    % write at the right offset. The LLDS back-end has not yet been
+    % wired up to either alternative, so accurate GC + LLDS still
+    % disables LCMC entirely.
+    globals.lookup_bool_option(!.Globals, highlevel_code, OT_HighLevelCode),
     ( if
         AllowSrcChangesDebug = allow_src_changes,
         ProfileDeep = bool.no,
         AllowOptLCMCTermSize = bool.yes,
-        GC_Method \= gc_accurate
+        ( GC_Method \= gc_accurate
+        ; OT_HighLevelCode = yes
+        )
     then
         OT_OptLCMC = OT_OptLCMC0
     else

compiler/hlds_pred.m

@@ -3577,7 +3577,9 @@
             (
                 OptTuple ^ ot_inline_builtins = inline_builtins
             ;
-                PredName = "store_at_ref_impure",
+                ( PredName = "store_at_ref_impure"
+                ; PredName = "store_at_field_offset_impure"
+                ),
                 ModuleName = mercury_private_builtin_module
             )
         ;

compiler/introduced_call_table.m

@@ -261,6 +261,7 @@
 mict_private_builtin("restore_hp",          1).
 mict_private_builtin("sorry",               1).
 mict_private_builtin("store_at_ref_impure", 2).
+mict_private_builtin("store_at_field_offset_impure", 3).
 mict_private_builtin("store_ticket",        1).
 mict_private_builtin("superclass_from_typeclass_info", 3).
 mict_private_builtin("trace_evaluate_runtime_condition", 0).