rusty: Add --online-change CLI flag

Author: CohenArthur

compiler/plc_driver/src/cli.rs

@@ -193,6 +193,12 @@ pub struct CompileParameters {
     #[clap(name = "check", long, help = "Check only, do not generate any output", global = true)]
     pub check_only: bool,
 
+    #[clap(
+        long,
+        help = "Emit a binary with specific compilation information, suitable for online changes when ran under a conforming runtime"
+    )]
+    pub online_change: bool,
+
     #[clap(subcommand)]
     pub commands: Option<SubCommands>,
 }

compiler/plc_driver/src/lib.rs

@@ -54,6 +54,7 @@ pub struct CompileOptions {
     pub error_format: ErrorFormat,
     pub debug_level: DebugLevel,
     pub single_module: bool,
+    pub online_change: bool,
 }
 
 impl Default for CompileOptions {
@@ -67,6 +68,7 @@ impl Default for CompileOptions {
             error_format: ErrorFormat::None,
             debug_level: DebugLevel::None,
             single_module: false,
+            online_change: false,
         }
     }
 }
@@ -176,6 +178,7 @@ pub fn get_compilation_context<T: AsRef<str> + AsRef<OsStr> + Debug>(
         error_format: compile_parameters.error_format,
         debug_level: compile_parameters.debug_level(),
         single_module: compile_parameters.single_module,
+        online_change: compile_parameters.online_change,
     };
 
     let libraries =

compiler/plc_driver/src/pipelines.rs

@@ -284,8 +284,16 @@ impl<T: SourceContainer + Sync> AnnotatedProject<T> {
             literals,
             dependencies,
             &self.index,
+            compile_options.online_change,
         )?;
-        code_generator.generate(context, unit, &self.annotations, &self.index, &llvm_index)
+        code_generator.generate(
+            context,
+            unit,
+            &self.annotations,
+            &self.index,
+            &llvm_index,
+            compile_options.online_change,
+        )
     }
 
     pub fn codegen_single_module<'ctx>(

src/codegen.rs

@@ -104,6 +104,7 @@ impl<'ink> CodeGen<'ink> {
         literals: &StringLiterals,
         dependencies: &IndexSet<Dependency>,
         global_index: &Index,
+        hot_reload: bool,
     ) -> Result<LlvmTypedIndex<'ink>, Diagnostic> {
         let llvm = Llvm::new(context, context.create_builder());
         let mut index = LlvmTypedIndex::default();
@@ -135,6 +136,7 @@ impl<'ink> CodeGen<'ink> {
             annotations,
             &index,
             &mut self.debug,
+            hot_reload,
         )?;
         let llvm = Llvm::new(context, context.create_builder());
         index.merge(llvm_impl_index);
@@ -194,10 +196,11 @@ impl<'ink> CodeGen<'ink> {
         annotations: &AstAnnotations,
         global_index: &Index,
         llvm_index: &LlvmTypedIndex,
+        hot_reload: bool,
     ) -> Result<GeneratedModule<'ink>, Diagnostic> {
         //generate all pous
         let llvm = Llvm::new(context, context.create_builder());
-        let pou_generator = PouGenerator::new(llvm, global_index, annotations, llvm_index);
+        let pou_generator = PouGenerator::new(llvm, global_index, annotations, llvm_index, hot_reload);
 
         //Generate the POU stubs in the first go to make sure they can be referenced.
         for implementation in &unit.implementations {

src/codegen/generators/pou_generator.rs

@@ -49,6 +49,7 @@ pub struct PouGenerator<'ink, 'cg> {
     index: &'cg Index,
     annotations: &'cg AstAnnotations,
     llvm_index: &'cg LlvmTypedIndex<'ink>,
+    online_change: bool,
 }
 
 /// Creates opaque implementations for all callable items in the index
@@ -61,9 +62,10 @@ pub fn generate_implementation_stubs<'ink>(
     annotations: &AstAnnotations,
     types_index: &LlvmTypedIndex<'ink>,
     debug: &mut DebugBuilderEnum<'ink>,
+    hot_reload: bool,
 ) -> Result<LlvmTypedIndex<'ink>, Diagnostic> {
     let mut llvm_index = LlvmTypedIndex::default();
-    let pou_generator = PouGenerator::new(llvm, index, annotations, types_index);
+    let pou_generator = PouGenerator::new(llvm, index, annotations, types_index, hot_reload);
     let implementations = dependencies
         .into_iter()
         .filter_map(|it| {
@@ -149,8 +151,9 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
         index: &'cg Index,
         annotations: &'cg AstAnnotations,
         llvm_index: &'cg LlvmTypedIndex<'ink>,
+        hot_reload: bool,
     ) -> PouGenerator<'ink, 'cg> {
-        PouGenerator { llvm, index, annotations, llvm_index }
+        PouGenerator { llvm, index, annotations, llvm_index, online_change: hot_reload }
     }
 
     fn mangle_function(&self, implementation: &ImplementationIndexEntry) -> String {
@@ -281,8 +284,10 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> {
 
         let curr_f = module.add_function(implementation.get_call_name(), function_declaration, None);
 
-        let section_name = self.mangle_function(implementation);
-        curr_f.set_section(Some(&section_name));
+        if self.online_change {
+            let section_name = self.mangle_function(implementation);
+            curr_f.set_section(Some(&section_name));
+        }
 
         let pou_name = implementation.get_call_name();
         if let Some(pou) = self.index.find_pou(pou_name) {

src/test_utils.rs

@@ -166,14 +166,14 @@ pub mod tests {
         );
         let annotations = AstAnnotations::new(annotations, id_provider.next_id());
         let llvm_index = code_generator
-            .generate_llvm_index(&context, &annotations, &literals, &dependencies, &index)
+            .generate_llvm_index(&context, &annotations, &literals, &dependencies, &index, false)
             .map_err(|err| {
                 reporter.handle(&[err]);
                 reporter.buffer().unwrap()
             })?;
 
         code_generator
-            .generate(&context, &unit, &annotations, &index, &llvm_index)
+            .generate(&context, &unit, &annotations, &index, &llvm_index, false)
             .map(|module| module.persist_to_string())
             .map_err(|err| {
                 reporter.handle(&[err]);
@@ -241,9 +241,10 @@ pub mod tests {
                     &literals,
                     &dependencies,
                     &index,
+                    false,
                 )?;
 
-                code_generator.generate(context, &unit, &annotations, &index, &llvm_index)
+                code_generator.generate(context, &unit, &annotations, &index, &llvm_index, false)
             })
             .collect::<Result<Vec<_>, Diagnostic>>()
     }