Just emit the used array constants

hercules_cg/src/top.rs

@@ -185,6 +185,12 @@ impl<'a> FunctionContext<'a> {
             param_types: self.function.param_types.clone(),
             return_type: self.function.return_type,
             typing: self.typing.clone(),
+            used_constants: self
+                .function
+                .nodes
+                .iter()
+                .filter_map(|node| node.try_constant())
+                .collect(),
             num_dynamic_constant_parameters: self.function.num_dynamic_constants,
             partitions: manifests,
             // TODO: populate dynamic constant rules.

hercules_ir/src/manifest.rs

@@ -57,6 +57,8 @@ pub struct FunctionManifest {
     // Types of all of the nodes in this function. Used for figuring out the
     // type of partition data inputs and outputs.
     pub typing: Vec<TypeID>,
+    // IDs of constants that are actually used in this function.
+    pub used_constants: Vec<ConstantID>,
     // Number of dynamic constant parameters that need to provided.
     pub num_dynamic_constant_parameters: u32,
     // Manifests for constituent partitions.

hercules_rt_proc/src/lib.rs

@@ -215,9 +215,13 @@ fn codegen(manifest: &ModuleManifest, elf: &[u8]) -> Result<String, anyhow::Erro
         // Declare all of the array constant memories. We declare them as Vecs
         // to allocate the memories. We emit multiplications of the dynamic
         // constant dimensions to allocate the whole memory as one contiguous
-        // range. TODO: emit only the array constants actually used in this
-        // function.
-        for (arr_cons_num, arr_cons_id) in manifest.array_cons_ids.iter().enumerate() {
+        // range.
+        for (arr_cons_num, arr_cons_id) in manifest
+            .array_cons_ids
+            .iter()
+            .filter(|id| function.used_constants.contains(id))
+            .enumerate()
+        {
             let arr_ty_id = manifest
                 .constant_types
                 .iter()