swamp_code_gen/
map.rs

1/*
2 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/swamp
3 * Licensed under the MIT License. See LICENSE in the project root for license information.
4 */
5use crate::code_bld::CodeBuilder;
6use crate::ctx::Context;
7use source_map_node::Node;
8use swamp_semantic::{Expression, MapType};
9use swamp_vm_isa::MemoryOffset;
10use swamp_vm_types::types::{BasicTypeRef, Place, VmType};
11use swamp_vm_types::{MemoryLocation, PointerLocation};
12
13impl CodeBuilder<'_> {
14    /// Emits Swamp VM opcodes to calculate the memory address of an element within a map.
15    pub fn map_subscript_helper(
16        &mut self,
17        map_header_location: &Place,
18        map_type: &MapType,
19        key_expression: &Expression,
20        should_create_if_needed: bool,
21        ctx: &Context,
22    ) -> Place {
23        let map_header_ptr_reg = self.emit_compute_effective_address_to_register(
24            map_header_location,
25            &key_expression.node,
26            "get map header absolute pointer",
27        );
28
29        let pointer_location = PointerLocation::new(map_header_ptr_reg);
30
31        // We have to get the key materialized in a temporary storage, so the map can calculate the hash for it.
32        let key_temp_storage_reg =
33            self.emit_aggregate_pointer_or_pointer_to_scalar_memory(key_expression, ctx);
34
35        let gen_value_type = self.state.layout_cache.layout(&map_type.value);
36        let map_entry_reg = self.temp_registers.allocate(
37            VmType::new_unknown_placement(gen_value_type.clone()),
38            "map entry temp",
39        );
40
41        if should_create_if_needed {
42            self.builder.add_map_get_or_reserve_entry_location(
43                map_entry_reg.register(),
44                &pointer_location,
45                &key_temp_storage_reg,
46                &key_expression.node,
47                "lookup the entry for this key, or create one, in the map",
48            );
49            // HACK: Initialize capacity
50            let map_value_pointer = MemoryLocation::new_copy_over_whole_type_with_zero_offset(
51                map_entry_reg.register.clone(),
52            );
53            self.emit_initialize_memory_for_any_type(
54                &map_value_pointer,
55                &key_expression.node,
56                "initialize the map value entry, just to be safe",
57            );
58        } else {
59            self.builder.add_map_get_entry_location(
60                map_entry_reg.register(),
61                &pointer_location,
62                &key_temp_storage_reg,
63                &key_expression.node,
64                "lookup the entry for this key in the map",
65            );
66        }
67
68        // a map subscript is always a memory location
69        Place::Memory(MemoryLocation {
70            base_ptr_reg: map_entry_reg.register,
71            offset: MemoryOffset(0),
72            ty: VmType::new_unknown_placement(gen_value_type),
73        })
74    }
75
76    pub(crate) fn emit_map_storage_init_from_initializer_pair_list(
77        &mut self,
78        target_map_header_ptr_reg: &PointerLocation, // Points to MapStorage
79        initializer_pair_list_expressions: &[(Expression, Expression)],
80        key_type: &BasicTypeRef,
81        value_type: &BasicTypeRef,
82        logical_limit: usize,
83        node: &Node,
84        comment: &str,
85        ctx: &Context,
86    ) {
87        let hwm = self.temp_registers.save_mark();
88
89        let safe_output_register = self.temp_registers.allocate(
90            VmType::new_contained_in_register(
91                target_map_header_ptr_reg.ptr_reg.ty.basic_type().clone(),
92            ),
93            "safe output destination for map initialization list",
94        );
95        self.builder.add_mov_reg(
96            &safe_output_register.register,
97            &target_map_header_ptr_reg.ptr_reg,
98            node,
99            "safe output register destination for map initialization",
100        );
101        let safe_output_map_header_pointer_location =
102            PointerLocation::new(safe_output_register.register);
103
104        let key_frame_location = self.allocate_frame_space_and_return_destination_to_it(
105            key_type,
106            node,
107            "key temporary storage",
108        );
109        let key_frame_place = key_frame_location
110            .vm_type()
111            .unwrap()
112            .frame_placed_type()
113            .unwrap();
114
115        let value_target_register = self.temp_registers.allocate(
116            VmType::new_unknown_placement(value_type.clone()),
117            "key temp",
118        );
119
120        for (key_expr, value_expr) in initializer_pair_list_expressions {
121            let initializer_pair_node = &key_expr.node;
122
123            if key_frame_location.ty().total_size.0 > 1 {
124                self.builder.add_frame_memory_clear(
125                    key_frame_place.region(),
126                    initializer_pair_node,
127                    "clear key area each time, to make sure hash is calculated correctly",
128                );
129            }
130
131            self.emit_expression_into_target_memory(
132                key_frame_location.grab_memory_location(),
133                key_expr,
134                "store key to memory",
135                ctx,
136            );
137
138            self.builder.add_map_get_or_reserve_entry_location(
139                value_target_register.register(),
140                &safe_output_map_header_pointer_location,
141                &key_frame_location.grab_memory_location().base_ptr_reg,
142                initializer_pair_node,
143                "find existing or create a map entry to write into",
144            );
145
146            let value_memory_location = MemoryLocation {
147                base_ptr_reg: value_target_register.register().clone(),
148                offset: MemoryOffset(0),
149                ty: VmType::new_unknown_placement(value_type.clone()),
150            };
151
152            // Initialize the allocated space first (like variable definition)
153            if value_type.is_aggregate() {
154                self.emit_initialize_memory_for_any_type(
155                    &value_memory_location,
156                    initializer_pair_node,
157                    "initialize map entry completely",
158                );
159            }
160
161            self.emit_expression_into_target_memory(
162                &value_memory_location,
163                value_expr,
164                "put value into map entry value section",
165                ctx,
166            );
167        }
168
169        self.temp_registers.restore_to_mark(hwm);
170    }
171}
swamp_code_gen/map.rs

swamp_code_gen/
map.rs
