chore: merge master

Author: volsa

scripts/build.sh

@@ -208,117 +208,96 @@ function set_offline() {
     fi
 }
 
+# Create shared library from static library with platform-specific flags
+function create_shared_library() {
+    local cc=$1
+    local lib_dir=$2
+    local target=$3
+    
+    log "Creating a shared library from the compiled static library"
+    
+    # Check if we're on macOS and adjust linker flags accordingly
+    case "$(uname -s)" in
+        Darwin*)
+            local cmd_args=("--shared" "-L$lib_dir" "-Wl,-force_load,$lib_dir/libiec61131std.a" "-o" "$lib_dir/libiec61131std.so" "-lm" "-framework" "CoreFoundation")
+            if [[ -n "$target" ]]; then
+                cmd_args+=("--target=$target")
+            fi
+            log "Running: $cc ${cmd_args[*]}"
+            "$cc" "${cmd_args[@]}"
+            ;;
+        *)
+            local cmd_args=("--shared" "-L$lib_dir" "-Wl,--whole-archive" "-liec61131std" "-o" "$lib_dir/libiec61131std.so" "-Wl,--no-whole-archive" "-lm" "-fuse-ld=lld")
+            if [[ -n "$target" ]]; then
+                cmd_args+=("--target=$target")
+            fi
+            log "Running: $cc ${cmd_args[*]}"
+            "$cc" "${cmd_args[@]}"
+            ;;
+    esac
+}
+
 function run_package_std() {
+    local cc
     cc=$(get_compiler)
-    OUTPUT_DIR=$project_location/output
+    local OUTPUT_DIR=$project_location/output
+    local target_dir="$project_location/target"
+    local include_dir=$OUTPUT_DIR/include
+    
     make_dir "$OUTPUT_DIR"
     log "Packaging Standard functions"
     log "Removing previous output folder"
-    rm -rf $OUTPUT_DIR
-    target_dir="$project_location/target"
-    include_dir=$OUTPUT_DIR/include
-    make_dir $include_dir
-    #Copy the iec61131-st folder
+    rm -rf "$OUTPUT_DIR"
+    make_dir "$include_dir"
+    
+    # Copy the iec61131-st folder
     cp -r "$project_location"/libs/stdlib/iec61131-st/*.st "$include_dir"
 
-    if [[ ! -z $target ]]; then
-        for val in ${target//,/ }
-        do
-            lib_dir=$OUTPUT_DIR/$val/lib
-            make_dir $lib_dir
+    if [[ -n "$target" ]]; then
+        for val in ${target//,/ }; do
+            local lib_dir=$OUTPUT_DIR/$val/lib
+            make_dir "$lib_dir"
 
-            # if the target ends with -linux-gnu but does not have unknown, add unknown
+            # Normalize target name for rustc
+            local rustc_target=$val
             if [[ $val == *"-linux-gnu" && $val != *"unknown-linux-gnu" ]]; then
                 rustc_target="${val/-linux-gnu/-unknown-linux-gnu}"
-            else
-                rustc_target=$val
             fi
-            rel_dir="$target_dir/$rustc_target"
+            
+            # Determine release or debug directory
+            local rel_dir="$target_dir/$rustc_target"
             if [[ $release -ne 0 ]]; then
                 rel_dir="$rel_dir/release"
             else
                 rel_dir="$rel_dir/debug"
             fi
+            
             if [[ ! -d "$rel_dir" ]]; then
                 echo "Compilation directory $rel_dir not found"
                 exit 1
             fi
-            cp "$rel_dir/"*.a "$lib_dir" 2>/dev/null  || log "$rel_dir does not contain *.a files"
-            # Create an SO file from the copied a file
-            log "Creating a shared library from the compiled static library"
-            # Check if we're on macOS and adjust linker flags accordingly
-            unameOut="$(uname -s)"
-            case "${unameOut}" in
-                Darwin*)
-                    log "Running : $cc --shared -L$lib_dir \
-                        -Wl,-force_load,$lib_dir/libiec61131std.a \
-                        -o $lib_dir/libiec61131std.so \
-                        -lm -framework CoreFoundation \
-                        --target=$val"
-                    $cc --shared -L"$lib_dir" \
-                        -Wl,-force_load,"$lib_dir/libiec61131std.a" \
-                        -o "$lib_dir/libiec61131std.so" \
-                        -lm -framework CoreFoundation \
-                        --target="$val"
-                    ;;
-                *)
-                    log "Running : $cc --shared -L$lib_dir \
-                        -Wl,--whole-archive -liec61131std \
-                        -o $lib_dir/libiec61131std.so -Wl,--no-whole-archive \
-                        -lm \
-                        -fuse-ld=lld \
-                        --target=$val"
-                    $cc --shared -L"$lib_dir" \
-                        -Wl,--whole-archive -liec61131std \
-                        -o "$lib_dir/libiec61131std.so" -Wl,--no-whole-archive \
-                        -lm \
-                        -fuse-ld=lld \
-                        --target="$val"
-                    ;;
-            esac
-
+            
+            cp "$rel_dir/"*.a "$lib_dir" 2>/dev/null || log "$rel_dir does not contain *.a files"
+            create_shared_library "$cc" "$lib_dir" "$val"
         done
     else
-        lib_dir=$OUTPUT_DIR/lib
-        make_dir $lib_dir
+        local lib_dir=$OUTPUT_DIR/lib
+        make_dir "$lib_dir"
+        
+        # Determine release or debug directory
+        local rel_dir="$target_dir"
         if [[ $release -ne 0 ]]; then
-            rel_dir="$target_dir/release"
+            rel_dir="$rel_dir/release"
         else
-            rel_dir="$target_dir/debug"
+            rel_dir="$rel_dir/debug"
         fi
+        
         cp "$rel_dir/"*.a "$lib_dir" 2>/dev/null || log "$rel_dir does not contain *.a files"
-        # Create an SO file from the copied a file
-        log "Creating a shared library from the compiled static library"
-        # Check if we're on macOS and adjust linker flags accordingly
-        unameOut="$(uname -s)"
-        case "${unameOut}" in
-            Darwin*)
-                log "Running : $cc --shared -L"$lib_dir" \
-                    -Wl,-force_load,$lib_dir/libiec61131std.a \
-                    -o "$lib_dir/libiec61131std.so" \
-                    -lm -framework CoreFoundation"
-                $cc --shared -L"$lib_dir" \
-                    -Wl,-force_load,"$lib_dir/libiec61131std.a" \
-                    -o "$lib_dir/libiec61131std.so" \
-                    -lm -framework CoreFoundation
-                ;;
-            *)
-                log "Running : $cc --shared -L"$lib_dir" \
-                    -Wl,--whole-archive -liec61131std \
-                    -o "$lib_dir/libiec61131std.so" -Wl,--no-whole-archive \
-                    -lm \
-                    -fuse-ld=lld "
-                $cc --shared -L"$lib_dir" \
-                    -Wl,--whole-archive -liec61131std \
-                    -o "$lib_dir/libiec61131std.so" -Wl,--no-whole-archive \
-                    -lm \
-                    -fuse-ld=lld
-                ;;
-        esac
+        create_shared_library "$cc" "$lib_dir" ""
     fi
 
     log "Enabling read/write on the output folder"
-    chmod -R a+rw $OUTPUT_DIR
+    chmod -R a+rw "$OUTPUT_DIR"
 
 }
 
@@ -536,9 +515,9 @@ if [[ $coverage -ne 0 ]]; then
     run_coverage
 fi
 
-if [[ -d $project_location/target/ ]]; then
+if [[ -d "$project_location/target/" ]]; then
     log "Allow access to target folders"
-    chmod -R a+rw $project_location/target/
+    chmod -R a+rw "$project_location/target/"
 fi
 
 if [[ $offline -ne 0 ]]; then

src/codegen/debug.rs

@@ -469,6 +469,18 @@ impl<'ink> DebugBuilder<'ink> {
             .map(|it| it.to_owned())
     }
 
+    /// Creates debug information for string types using an array + typedef approach.
+    ///
+    /// This function generates DWARF debug metadata for string types by creating:
+    /// 1. A character array type based on the string's encoding (CHAR for UTF-8, WCHAR for UTF-16)
+    /// 2. A typedef with a unique name based on encoding and length (e.g., "__STRING__81", "__WSTRING__26")
+    ///
+    /// ## Typedef Naming
+    ///
+    /// The typedef uses the `__STRING__<grapheme count>` or `__WSTRING__<grapheme count>` pattern where:
+    /// - Double underscore prefix avoids clashing with user-defined types (reserved for compiler internals)
+    /// - Length suffix ensures each string type has a unique DWARF reference
+    /// - Consistent pattern enables easy detection by DWARF parsers
     fn create_string_type(
         &mut self,
         name: &str,
@@ -478,24 +490,37 @@ impl<'ink> DebugBuilder<'ink> {
         index: &Index,
         types_index: &LlvmTypedIndex,
     ) -> Result<(), Diagnostic> {
-        // Register a utf8 or 16 basic type
-        let inner_type = match encoding {
+        let char_datatype = match encoding {
             StringEncoding::Utf8 => index.get_effective_type_or_void_by_name(CHAR_TYPE),
             StringEncoding::Utf16 => index.get_effective_type_or_void_by_name(WCHAR_TYPE),
         };
-        let inner_type = self.get_or_create_debug_type(inner_type, index, types_index)?;
-        let llvm_type = types_index.get_associated_type(name)?;
-        let align_bits = self.target_data.get_preferred_alignment(&llvm_type) * 8;
-        //Register an array
+
+        let char_debug_type = self.get_or_create_debug_type(char_datatype, index, types_index)?;
+        let array_align_bits =
+            self.target_data.get_preferred_alignment(&types_index.get_associated_type(name)?) * 8;
         let array_type = self.debug_info.create_array_type(
-            inner_type.into(),
+            char_debug_type.into(),
             size,
-            align_bits,
+            array_align_bits,
             #[allow(clippy::single_range_in_vec_init)]
-            &[(0..length)],
+            &[0..length],
         );
+        let typedef_name = match encoding {
+            StringEncoding::Utf8 => format!("__STRING__{}", length),
+            StringEncoding::Utf16 => format!("__WSTRING__{}", length),
+        };
 
-        self.register_concrete_type(name, DebugType::Composite(array_type));
+        let file = self.compile_unit.get_file();
+        let string_typedef = self.debug_info.create_typedef(
+            array_type.as_type(),
+            &typedef_name,
+            file,
+            0, // Line 0 for built-in types
+            file.as_debug_info_scope(),
+            array_align_bits,
+        );
+
+        self.register_concrete_type(name, DebugType::Derived(string_typedef));
         Ok(())
     }
 

src/codegen/generators/data_type_generator.rs

@@ -286,30 +286,29 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
         }
     }
 
-    // TODO(vosa): Is this neccessary? Are the function types indexed and later on used in the expression
-    // generator? If not this whole commit could be reverted, double-check before merging
-    fn create_function_type(&mut self, pou_name: &str) -> Result<FunctionType<'ink>, Diagnostic> {
+    fn create_function_type(&mut self, method_name: &str) -> Result<FunctionType<'ink>, Diagnostic> {
         let return_type = self
             .types_index
-            .find_associated_type(self.index.get_return_type_or_void(pou_name).get_name())
+            .find_associated_type(self.index.get_return_type_or_void(method_name).get_name())
             .map(|opt| opt.as_any_type_enum())
             .unwrap_or(self.llvm.context.void_type().as_any_type_enum());
 
         let mut parameter_types = Vec::new();
 
-        // Methods are defined as functions in the LLVM IR, but carry the underlying POU type as their first
-        // parameter to operate on them, hence push the POU type to the very first position.
-        match self.index.find_pou(pou_name) {
+        match self.index.find_pou(method_name) {
             Some(PouIndexEntry::Method { parent_name, .. }) => {
                 let ty = self.types_index.get_associated_type(parent_name).expect("must exist");
                 let ty_ptr = ty.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into();
 
+                // Methods are defined as functions in the LLVM IR, but carry the underlying POU type as their
+                // first parameter to operate on them, hence push the POU type to the very first position.
                 parameter_types.push(ty_ptr);
-                for parameter in self.index.get_declared_parameters(pou_name) {
-                    // Instead of relying on the LLVM index, we create data-types directly in here because some of
-                    // them may not have been registered yet. For example, at the time of writing this comment the
-                    // `__auto_pointer_to_DINT` type was not present in the index for a VAR_IN_OUT parameter which
-                    // resulted in an error
+
+                for parameter in self.index.get_declared_parameters(method_name) {
+                    // Instead of relying on the LLVM index, we create data-types on the fly here because some
+                    // types have not yet been visited and as a result may not be in the index. For example at
+                    // the time of writing this the index was not able to find a input parameter of type
+                    // `__auto_pointer_to_DINT`, consequently panicking
                     let ty = self.create_type(
                         parameter.get_name(),
                         self.index.get_type(&parameter.data_type_name).expect("must exist"),
@@ -319,13 +318,13 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
                 }
             }
 
-            // Function blocks are a bit "weird" in that they only expect an instance argument even if they
-            // define input, output and/or inout parameters. Effectively, while being methods per-se, their
-            // calling convention differs from regular methods.
             Some(PouIndexEntry::FunctionBlock { name, .. }) => {
                 let ty = self.types_index.get_associated_type(name).expect("must exist");
                 let ty_ptr = ty.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into();
 
+                // Function blocks are a bit "weird" in that they only expect an instance argument even if
+                // they define input, output and/or inout parameters. Effectively, while being methods per-se,
+                // their calling convention differs from regular methods.
                 parameter_types.push(ty_ptr);
             }
 

src/codegen/generators/expression_generator.rs

@@ -490,7 +490,6 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         operator: &AstNode,
         parameters: Option<&AstNode>,
     ) -> Result<ExpressionValue<'ink>, Diagnostic> {
-        // Check if we are dealing with something alike `foo^(...)`
         if self.annotations.get(operator).is_some_and(StatementAnnotation::is_fnptr) {
             return self.generate_fnptr_call(operator, parameters);
         }
@@ -595,6 +594,8 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         arguments: Option<&AstNode>,
     ) -> Result<ExpressionValue<'ink>, Diagnostic> {
         let Some(ReferenceExpr { base: Some(ref base), .. }) = operator.get_deref_expr() else {
+            // XXX: This would fail for auto-deref pointers, but given (for now) function pointers are never
+            // auto-derefed this should be fine.
             unreachable!("internal error, invalid method call")
         };
 
@@ -612,9 +613,9 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             ExpressionValue::RValue(_) => unreachable!(),
         };
 
-        // Generate the argument list; our assumption is function pointers are only supported for methods
-        // right now, hence we explicitly fetch the instance arguments from the list. In desugared code it we
-        // would have something alike `fnPtr^(instanceFb, arg1, arg2, ..., argN)`
+        // Generate the argument list; our assumption is function pointers are only supported for methods and
+        // direct function block calls, hence we explicitly fetch the instance argument from the list. In
+        // terms of desugared ST code you can imagine something alike `fnPtr^(instanceFb, arg1, ..., argN)`
         let (instance, arguments_raw, arguments_llvm) = {
             let arguments = arguments.map(flatten_expression_list).unwrap_or_default();
             let (instance, arguments) = match arguments.len() {
@@ -652,13 +653,10 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
 
         let value = match call.try_as_basic_value() {
             Either::Left(value) => value,
-            Either::Right(_) => {
-                // TODO: When is this neccessary?
-                get_llvm_int_type(self.llvm.context, INT_SIZE, INT_TYPE)
-                    .ptr_type(AddressSpace::from(ADDRESS_SPACE_CONST))
-                    .const_null()
-                    .as_basic_value_enum()
-            }
+            Either::Right(_) => get_llvm_int_type(self.llvm.context, INT_SIZE, INT_TYPE)
+                .ptr_type(AddressSpace::from(ADDRESS_SPACE_CONST))
+                .const_null()
+                .as_basic_value_enum(),
         };
 
         // Output variables are assigned after the function block call, effectively gep'ing the instance

src/codegen/llvm_index.rs

@@ -27,7 +27,6 @@ pub struct LlvmTypedIndex<'ink> {
 pub trait TypeHelper<'ink> {
     #[allow(clippy::wrong_self_convention)]
     fn as_basic_type(self) -> Option<BasicTypeEnum<'ink>>;
-
     fn create_ptr_type(&self, address_space: AddressSpace) -> PointerType<'ink>;
 }