feat: Aliased Hardware Access Variables (#1265)

feat: Aliased Hardware Access Variables

Adds support to create new hardware variables by declaring a global variable with the address
For example :

VAR_GLOBAL
  heatSwitch AT %IX1.2.3.4 : BOOL;
END_VAR

will create a variable __PI_1_2_3_4 : BOOL and map the heatSwitch variable to it.
A runtime can then point the __PI_1_2_3_4 to a real hardware value.
This PR still does not allow declaring hardware addresses with no associated variables.
Assigning variables inside POUs is also not possible

Author: volsa

compiler/plc_ast/src/ast.rs

@@ -471,6 +471,20 @@ impl DataTypeDeclaration {
         let DataTypeDeclaration::DataTypeReference { referenced_type, .. } = self else { return None };
         Some(referenced_type.to_owned())
     }
+
+    pub fn get_inner_pointer_ty(&self) -> Option<DataTypeDeclaration> {
+        match self {
+            DataTypeDeclaration::DataTypeReference { .. } => Some(self.clone()),
+
+            DataTypeDeclaration::DataTypeDefinition { data_type, .. } => {
+                if let DataType::PointerType { referenced_type, .. } = data_type {
+                    return referenced_type.get_inner_pointer_ty();
+                }
+
+                None
+            }
+        }
+    }
 }
 
 #[derive(PartialEq)]

compiler/plc_ast/src/pre_processor.rs

@@ -7,7 +7,8 @@ use plc_util::convention::internal_type_name;
 use crate::{
     ast::{
         flatten_expression_list, Assignment, AstFactory, AstNode, AstStatement, CompilationUnit, DataType,
-        DataTypeDeclaration, Operator, Pou, UserTypeDeclaration, Variable,
+        DataTypeDeclaration, DirectAccessType, HardwareAccess, HardwareAccessType, Operator, Pou,
+        UserTypeDeclaration, Variable, VariableBlockType,
     },
     literals::AstLiteral,
     provider::IdProvider,
@@ -21,13 +22,13 @@ pub fn pre_process(unit: &mut CompilationUnit, mut id_provider: IdProvider) {
         let generic_types = preprocess_generic_structs(pou);
         unit.user_types.extend(generic_types);
 
-        let all_variables = pou
+        let local_variables = pou
             .variable_blocks
             .iter_mut()
             .flat_map(|it| it.variables.iter_mut())
             .filter(|it| should_generate_implicit_type(it));
 
-        for var in all_variables {
+        for var in local_variables {
             pre_process_variable_data_type(pou.name.as_str(), var, &mut unit.user_types)
         }
 
@@ -36,15 +37,7 @@ pub fn pre_process(unit: &mut CompilationUnit, mut id_provider: IdProvider) {
     }
 
     //process all variables from GVLs
-    let all_variables = unit
-        .global_vars
-        .iter_mut()
-        .flat_map(|gv| gv.variables.iter_mut())
-        .filter(|it| should_generate_implicit_type(it));
-
-    for var in all_variables {
-        pre_process_variable_data_type("global", var, &mut unit.user_types)
-    }
+    process_global_variables(unit, &mut id_provider);
 
     //process all variables in dataTypes
     let mut new_types = vec![];
@@ -150,6 +143,68 @@ pub fn pre_process(unit: &mut CompilationUnit, mut id_provider: IdProvider) {
     unit.user_types.append(&mut new_types);
 }
 
+fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProvider) {
+    let mut mangled_globals = Vec::new();
+
+    for global_var in unit.global_vars.iter_mut().flat_map(|block| block.variables.iter_mut()) {
+        let ref_ty = global_var.data_type_declaration.get_inner_pointer_ty();
+
+        if should_generate_implicit_type(global_var) {
+            pre_process_variable_data_type("global", global_var, &mut unit.user_types)
+        }
+
+        // In any case, we have to inject initializers into aliased hardware access variables
+        if let Some(ref node) = global_var.address {
+            if let AstStatement::HardwareAccess(HardwareAccess { direction, access, address }) = &node.stmt {
+                let direction = match direction {
+                    HardwareAccessType::Input | HardwareAccessType::Output => "PI",
+                    HardwareAccessType::Memory => "M",
+                    HardwareAccessType::Global => "G",
+                };
+                let name = format!(
+                    "__{direction}_{}",
+                    address
+                        .iter()
+                        .flat_map(|node| node.get_literal_integer_value())
+                        .map(|val| val.to_string())
+                        .collect::<Vec<_>>()
+                        .join("_")
+                );
+
+                // %I*: DWORD; should not be declared at this stage, it is just skipped
+                if matches!(access, DirectAccessType::Template) {
+                    continue;
+                }
+
+                let mangled_initializer = AstFactory::create_member_reference(
+                    AstFactory::create_identifier(&name, SourceLocation::internal(), id_provider.next_id()),
+                    None,
+                    id_provider.next_id(),
+                );
+
+                global_var.initializer = Some(mangled_initializer);
+
+                let internal_mangled_var = Variable {
+                    name,
+                    data_type_declaration: ref_ty.unwrap_or(global_var.data_type_declaration.clone()),
+                    initializer: None,
+                    address: None,
+                    location: SourceLocation::internal(),
+                };
+                mangled_globals.push(internal_mangled_var);
+            }
+        }
+    }
+
+    if let Some(block) =
+        unit.global_vars.iter_mut().find(|block| block.variable_block_type == VariableBlockType::Global)
+    {
+        for new_var in mangled_globals {
+            block.variables.push(new_var);
+        }
+    }
+}
+
 fn build_enum_initializer(
     last_name: &Option<String>,
     location: &SourceLocation,

src/codegen/tests.rs

@@ -1,4 +1,5 @@
 // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
+mod address_tests;
 mod code_gen_tests;
 mod codegen_error_messages_tests;
 mod compare_instructions_tests;

src/codegen/tests/address_tests.rs

@@ -0,0 +1,141 @@
+use insta::assert_snapshot;
+
+use crate::test_utils::tests::codegen;
+
+#[test]
+fn aliased_address_in_global_generated() {
+    let res = codegen(
+        r"
+            VAR_GLOBAL
+                foo AT %IX1.2.3.4 : BOOL;
+            END_VAR
+        ",
+    );
+
+    assert_snapshot!(res, @r###"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+
+    @foo = global i8* null, section "var-$RUSTY$foo:pu8"
+    @__PI_1_2_3_4 = global i8 0, section "var-$RUSTY$__PI_1_2_3_4:u8"
+    ; ModuleID = '__init___testproject'
+    source_filename = "__init___testproject"
+
+    @__PI_1_2_3_4 = external global i8, section "var-$RUSTY$__PI_1_2_3_4:u8"
+    @foo = external global i8*, section "var-$RUSTY$foo:pu8"
+
+    define void @__init___testproject() section "fn-$RUSTY$__init___testproject:v" {
+    entry:
+      store i8* @__PI_1_2_3_4, i8** @foo, align 8
+      ret void
+    }
+    "###);
+}
+
+#[test]
+fn duplicate_aliased_address_in_global_generated() {
+    let res = codegen(
+        r"
+            VAR_GLOBAL
+                foo AT %IX1.2.3.4 : BOOL;
+                baz AT %IX1.2.3.4 : BOOL;
+            END_VAR
+        ",
+    );
+
+    assert_snapshot!(res, @r###"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+
+    @foo = global i8* null, section "var-$RUSTY$foo:pu8"
+    @__PI_1_2_3_4 = global i8 0, section "var-$RUSTY$__PI_1_2_3_4:u8"
+    @baz = global i8* null, section "var-$RUSTY$baz:pu8"
+    ; ModuleID = '__init___testproject'
+    source_filename = "__init___testproject"
+
+    @__PI_1_2_3_4 = external global i8, section "var-$RUSTY$__PI_1_2_3_4:u8"
+    @foo = external global i8*, section "var-$RUSTY$foo:pu8"
+    @baz = external global i8*, section "var-$RUSTY$baz:pu8"
+
+    define void @__init___testproject() section "fn-$RUSTY$__init___testproject:v" {
+    entry:
+      store i8* @__PI_1_2_3_4, i8** @foo, align 8
+      store i8* @__PI_1_2_3_4, i8** @baz, align 8
+      ret void
+    }
+    "###);
+}
+
+#[test]
+fn address_variable_used_with_symbolic_name() {
+    let res = codegen(
+        r"
+            VAR_GLOBAL
+                foo AT %IX1.2.3.4 : BOOL;
+                baz AT %IX1.2.3.4 : BOOL;
+            END_VAR
+
+            PROGRAM mainProg
+                foo := FALSE;
+                baz := TRUE;
+            END_PROGRAM
+        ",
+    );
+
+    assert_snapshot!(res, @r###"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+
+    %mainProg = type {}
+
+    @foo = global i8* null, section "var-$RUSTY$foo:pu8"
+    @__PI_1_2_3_4 = global i8 0, section "var-$RUSTY$__PI_1_2_3_4:u8"
+    @baz = global i8* null, section "var-$RUSTY$baz:pu8"
+    @mainProg_instance = global %mainProg zeroinitializer, section "var-$RUSTY$mainProg_instance:r0"
+
+    define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" {
+    entry:
+      %deref = load i8*, i8** @foo, align 8
+      store i8 0, i8* %deref, align 1
+      %deref1 = load i8*, i8** @baz, align 8
+      store i8 1, i8* %deref1, align 1
+      ret void
+    }
+    ; ModuleID = '__initializers'
+    source_filename = "__initializers"
+
+    %mainProg = type {}
+
+    @mainProg_instance = external global %mainProg, section "var-$RUSTY$mainProg_instance:r0"
+
+    define void @__init_mainprog(%mainProg* %0) section "fn-$RUSTY$__init_mainprog:v[pr0]" {
+    entry:
+      %self = alloca %mainProg*, align 8
+      store %mainProg* %0, %mainProg** %self, align 8
+      ret void
+    }
+
+    declare void @mainProg(%mainProg*) section "fn-$RUSTY$mainProg:v"
+    ; ModuleID = '__init___testproject'
+    source_filename = "__init___testproject"
+
+    %mainProg = type {}
+
+    @__PI_1_2_3_4 = external global i8, section "var-$RUSTY$__PI_1_2_3_4:u8"
+    @foo = external global i8*, section "var-$RUSTY$foo:pu8"
+    @baz = external global i8*, section "var-$RUSTY$baz:pu8"
+    @mainProg_instance = external global %mainProg, section "var-$RUSTY$mainProg_instance:r0"
+
+    define void @__init___testproject() section "fn-$RUSTY$__init___testproject:v" {
+    entry:
+      store i8* @__PI_1_2_3_4, i8** @foo, align 8
+      store i8* @__PI_1_2_3_4, i8** @baz, align 8
+      call void @__init_mainprog(%mainProg* @mainProg_instance)
+      ret void
+    }
+
+    declare void @__init_mainprog(%mainProg*) section "fn-$RUSTY$__init_mainprog:v[pr0]"
+
+    declare void @mainProg(%mainProg*) section "fn-$RUSTY$mainProg:v"
+    "###);
+}