feat: Add support for hardware references in code (#1293)

* feat: allow hardware address to be used in the code

A hardware address used in the body is now resolved to the appropriate
global variable.
ONly resolving is done so far, codegen will follow

* Add codgen support for hardware addresses

Hardware references are now generated as a reference to the global
variable

* Add a lit test, not yet executed

* Update lit test to use checks

* add init function and fix test for lit

* Removed all codegen snaps and regenerated them

Author: ghaith

compiler/plc_ast/src/ast.rs

@@ -1707,3 +1707,27 @@ pub struct JumpStatement {
 pub struct LabelStatement {
     pub name: String,
 }
+
+impl HardwareAccess {
+    pub fn get_mangled_variable_name(&self) -> String {
+        let HardwareAccess { direction, address, .. } = self;
+        let direction = match direction {
+            HardwareAccessType::Input | HardwareAccessType::Output => "PI",
+            HardwareAccessType::Memory => "M",
+            HardwareAccessType::Global => "G",
+        };
+        format!(
+            "__{direction}_{}",
+            address
+                .iter()
+                .flat_map(|node| node.get_literal_integer_value())
+                .map(|val| val.to_string())
+                .collect::<Vec<_>>()
+                .join("_")
+        )
+    }
+
+    pub fn is_template(&self) -> bool {
+        matches!(self.access, DirectAccessType::Template)
+    }
+}

compiler/plc_ast/src/pre_processor.rs

@@ -7,8 +7,7 @@ use plc_util::convention::internal_type_name;
 use crate::{
     ast::{
         flatten_expression_list, Assignment, AstFactory, AstNode, AstStatement, CompilationUnit, DataType,
-        DataTypeDeclaration, DirectAccessType, HardwareAccess, HardwareAccessType, Operator, Pou,
-        UserTypeDeclaration, Variable, VariableBlock, VariableBlockType,
+        DataTypeDeclaration, Operator, Pou, UserTypeDeclaration, Variable, VariableBlock, VariableBlockType,
     },
     literals::AstLiteral,
     provider::IdProvider,
@@ -155,24 +154,11 @@ fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProv
 
         // 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("_")
-                );
+            if let AstStatement::HardwareAccess(hardware) = &node.stmt {
+                let name = hardware.get_mangled_variable_name();
 
                 // %I*: DWORD; should not be declared at this stage, it is just skipped
-                if matches!(access, DirectAccessType::Template) {
+                if hardware.is_template() {
                     continue;
                 }
 

src/codegen/generators/expression_generator.rs

@@ -236,6 +236,9 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 };
                 Ok(val)
             }
+            AstStatement::HardwareAccess(..) => self
+                .create_llvm_pointer_value_for_reference(None, "address", expression)
+                .map(ExpressionValue::LValue),
             AstStatement::BinaryExpression(data) => self
                 .generate_binary_expression(&data.left, &data.right, &data.operator, expression)
                 .map(ExpressionValue::RValue),
@@ -245,10 +248,6 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
             AstStatement::UnaryExpression(data) => {
                 self.generate_unary_expression(&data.operator, &data.value).map(ExpressionValue::RValue)
             }
-            // TODO: Hardware access needs to be evaluated, see #648
-            AstStatement::HardwareAccess { .. } => {
-                Ok(ExpressionValue::RValue(self.llvm.i32_type().const_zero().into()))
-            }
             AstStatement::ParenExpression(expr) => self.generate_expression_value(expr),
             //fallback
             _ => self.generate_literal(expression),

src/codegen/generators/statement_generator.rs

@@ -286,10 +286,6 @@ impl<'a, 'b> StatementCodeGenerator<'a, 'b> {
             return self.generate_ref_assignment(left_statement, right_statement);
         };
 
-        //TODO: Also hacky but for now we cannot generate assignments for hardware access
-        if matches!(left_statement.get_stmt(), AstStatement::HardwareAccess { .. }) {
-            return Ok(());
-        }
         let exp_gen = self.create_expr_generator();
         let left: PointerValue = exp_gen.generate_expression_value(left_statement).and_then(|it| {
             it.get_basic_value_enum().try_into().map_err(|err| {

src/codegen/tests/address_tests.rs

@@ -139,3 +139,80 @@ fn address_variable_used_with_symbolic_name() {
     declare void @mainProg(%mainProg*) section "fn-$RUSTY$mainProg:v"
     "###);
 }
+
+#[test]
+fn address_used_in_body() {
+    let res = codegen(
+        r"
+            VAR_GLOBAL
+                foo AT %IX1.2.3.4 : BOOL;
+                baz AT %QX1.2.3.5 : BOOL;
+                x : BOOL := TRUE;
+            END_VAR
+
+            PROGRAM mainProg
+                %IX1.2.3.4 := TRUE;
+                x := %QX1.2.3.5;                 
+            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"
+    @__PI_1_2_3_5 = global i8 0, section "var-$RUSTY$__PI_1_2_3_5:u8"
+    @x = global i8 1, section "var-$RUSTY$x:u8"
+    @mainProg_instance = global %mainProg zeroinitializer, section "var-$RUSTY$mainProg_instance:r0"
+
+    define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" {
+    entry:
+      store i8 1, i8* @__PI_1_2_3_4, align 1
+      %1 = load i8, i8* @__PI_1_2_3_5, align 1
+      store i8 %1, i8* @x, 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"
+    @__PI_1_2_3_5 = external global i8, section "var-$RUSTY$__PI_1_2_3_5:u8"
+    @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_5, 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"
+    "###);
+}

src/codegen/tests/expression_tests.rs

@@ -518,48 +518,6 @@ fn compare_date_time_literals() {
     insta::assert_snapshot!(result);
 }
 
-#[test]
-fn hardware_access_codegen() {
-    let result = codegen(
-        "
-        PROGRAM prg
-        VAR
-          x,y,z : BYTE;
-        END_VAR
-          x := %IB1.2;
-          y := %MB1.2;
-          z := %GB1.2;
-          x := %IX1.2;
-          y := %MD1.2;
-          z := %GW1.2;
-        END_PROGRAM
-        ",
-    );
-
-    insta::assert_snapshot!(result);
-}
-
-#[test]
-fn hardware_access_assign_codegen() {
-    let result = codegen(
-        "
-        PROGRAM prg
-        VAR
-          x,y,z : BYTE;
-        END_VAR
-          %IB1.2 := 1;
-          %MB1.2 := 1;
-          %GB1.2 := 1;
-          %IX1.2 := 1;
-          %MD1.2 := 1;
-          %GW1.2 := 1;
-        END_PROGRAM
-        ",
-    );
-
-    insta::assert_snapshot!(result);
-}
-
 #[test]
 fn allowed_assignable_types() {
     let result = codegen(

src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_invalid_declaration.snap

@@ -7,5 +7,3 @@ error[E071]: Cannot generate CHAR from empty literal
   │
 6 │         x := '';
   │              ^^ Cannot generate CHAR from empty literal
-
-

src/codegen/tests/snapshots/rusty__codegen__tests__codegen_error_messages_tests__assigning_empty_string_literal_to_char_results_in_error.snap

@@ -7,5 +7,3 @@ error[E071]: Cannot generate WCHAR from empty literal
   │
 6 │         x := "";
   │              ^^ Cannot generate WCHAR from empty literal
-
-

src/codegen/tests/snapshots/rusty__codegen__tests__codegen_error_messages_tests__assigning_empty_string_literal_to_wide_char_results_in_error.snap

@@ -7,5 +7,3 @@ error[E074]: Cannot generate String-Literal for type INT
   │
 6 │         x := 'A';
   │              ^^^ Cannot generate String-Literal for type INT
-
-