codegen: Move type mangling to its own module

This enables sharing the type mangling with the variable generator

Author: CohenArthur

src/codegen/generators.rs

@@ -2,6 +2,7 @@ pub mod data_type_generator;
 pub mod expression_generator;
 pub mod llvm;
 pub mod pou_generator;
+pub mod section_names;
 pub mod statement_generator;
 pub mod variable_generator;
 

src/codegen/generators/pou_generator.rs

@@ -4,6 +4,7 @@ use super::{
     data_type_generator::get_default_for,
     expression_generator::ExpressionCodeGenerator,
     llvm::{GlobalValueExt, Llvm},
+    section_names,
     statement_generator::{FunctionContext, StatementCodeGenerator},
     ADDRESS_SPACE_GENERIC,
 };
@@ -14,7 +15,7 @@ use crate::{
     },
     index::{self, ImplementationType},
     resolver::{AstAnnotations, Dependency},
-    typesystem::{self, DataType, DataTypeInformation, StringEncoding, TypeSize, VarArgs},
+    typesystem::{self, DataType, VarArgs},
 };
 use std::collections::HashMap;
 
@@ -40,7 +41,7 @@ use inkwell::{
 use plc_ast::ast::{AstNode, Implementation, PouType};
 use plc_diagnostics::diagnostics::{Diagnostic, INTERNAL_LLVM_ERROR};
 use plc_source::source_location::SourceLocation;
-use section_mangler::{FunctionArgument, SectionMangler, StringEncoding as SectionStringEncoding, Type};
+use section_mangler::{FunctionArgument, SectionMangler};
 
 pub struct PouGenerator<'ink, 'cg> {
     llvm: Llvm<'ink>,
@@ -158,7 +159,10 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
 
         let ctx = params.into_iter().fold(ctx, |ctx, param| {
             // FIXME: Can we unwrap here?
-            let ty = self.mangle_type(self.index.get_effective_type_by_name(&param.data_type_name).unwrap());
+            let ty = section_names::mangle_type(
+                self.index,
+                self.index.get_effective_type_by_name(&param.data_type_name).unwrap(),
+            );
             let parameter = match param.argument_type {
                 // TODO: We need to handle the `VariableType` enum as well - this describes the mode of
                 // argument passing, e.g. inout
@@ -169,44 +173,14 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
             ctx.with_parameter(parameter)
         });
 
-        let return_ty =
-            self.index.find_return_type(implementation.get_type_name()).map(|ty| self.mangle_type(ty));
+        let return_ty = self
+            .index
+            .find_return_type(implementation.get_type_name())
+            .map(|ty| section_names::mangle_type(self.index, ty));
 
         ctx.with_return_type(return_ty).mangle()
     }
 
-    fn mangle_type(&self, ty: &typesystem::DataType) -> Type {
-        // TODO: This is a bit ugly because we keep dereferencing references to Copy types like
-        // bool, u32, etc, because `DataTypeInformation::Pointer` keeps a `String` which is not
-        // Copy. the alternative is for section_mangle::Type to keep references everywhere, and
-        // have a lifetime generic parameter, e.g. `section_mangler::Type<'a>` - which is also
-        // annoying.
-        match ty.get_type_information() {
-            DataTypeInformation::Void => Type::Void,
-            DataTypeInformation::Integer { signed, size, semantic_size, .. } => {
-                Type::Integer { signed: *signed, size: *size, semantic_size: *semantic_size }
-            }
-            DataTypeInformation::Float { size, .. } => Type::Float { size: *size },
-            DataTypeInformation::String { size: TypeSize::LiteralInteger(size), encoding } => {
-                let encoding = match encoding {
-                    StringEncoding::Utf8 => SectionStringEncoding::Utf8,
-                    StringEncoding::Utf16 => SectionStringEncoding::Utf16,
-                };
-
-                Type::String { size: *size as usize, encoding }
-            }
-            DataTypeInformation::Pointer { inner_type_name, .. } => Type::Pointer {
-                inner: Box::new(
-                    self.mangle_type(self.index.get_effective_type_by_name(inner_type_name).unwrap()),
-                ),
-            },
-            // FIXME: For now, encode all unknown types as "void" since this is not required for
-            // execution. Not doing so (and doing an `unreachable!()` for example) obviously causes
-            // failures, because complex types are already implemented in the compiler.
-            _ => Type::Void,
-        }
-    }
-
     /// generates an empty llvm function for the given implementation, including all parameters and the return type
     pub fn generate_implementation_stub(
         &self,

src/codegen/generators/section_names.rs

@@ -0,0 +1,33 @@
+use crate::index::Index;
+use crate::typesystem::{self, DataTypeInformation, StringEncoding, TypeSize};
+use section_mangler::{StringEncoding as SectionStringEncoding, Type};
+
+pub fn mangle_type(index: &Index, ty: &typesystem::DataType) -> section_mangler::Type {
+    // TODO: This is a bit ugly because we keep dereferencing references to Copy types like
+    // bool, u32, etc, because `DataTypeInformation::Pointer` keeps a `String` which is not
+    // Copy. the alternative is for section_mangle::Type to keep references everywhere, and
+    // have a lifetime generic parameter, e.g. `section_mangler::Type<'a>` - which is also
+    // annoying.
+    match ty.get_type_information() {
+        DataTypeInformation::Void => Type::Void,
+        DataTypeInformation::Integer { signed, size, semantic_size, .. } => {
+            Type::Integer { signed: *signed, size: *size, semantic_size: *semantic_size }
+        }
+        DataTypeInformation::Float { size, .. } => Type::Float { size: *size },
+        DataTypeInformation::String { size: TypeSize::LiteralInteger(size), encoding } => {
+            let encoding = match encoding {
+                StringEncoding::Utf8 => SectionStringEncoding::Utf8,
+                StringEncoding::Utf16 => SectionStringEncoding::Utf16,
+            };
+
+            Type::String { size: *size as usize, encoding }
+        }
+        DataTypeInformation::Pointer { inner_type_name, .. } => Type::Pointer {
+            inner: Box::new(mangle_type(index, index.get_effective_type_by_name(inner_type_name).unwrap())),
+        },
+        // FIXME: For now, encode all unknown types as "void" since this is not required for
+        // execution. Not doing so (and doing an `unreachable!()` for example) obviously causes
+        // failures, because complex types are already implemented in the compiler.
+        _ => Type::Void,
+    }
+}