[assembler] Place default-assigned tags at the end of the RC block.

This matches the behaviour of the TX-2's original M4 assembler, and
it's possible that user programs could depend on this (and detect it,
for example, by subtracting the addressed of two default-assigned
symbols).

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -347,6 +347,10 @@ impl RegistersContaining {
         &self.0
     }
 
+    pub(crate) fn words_mut(&mut self) -> impl Iterator<Item = &mut RegisterContaining> {
+        self.0.iter_mut()
+    }
+
     fn symbol_uses(
         &self,
         block_id: BlockIdentifier,
@@ -359,17 +363,23 @@ impl RegistersContaining {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct RegisterContaining(Box<TaggedProgramInstruction>);
+pub(crate) enum RegisterContaining {
+    Unallocated(Box<TaggedProgramInstruction>),
+    Allocated(Address, Box<TaggedProgramInstruction>),
+}
 
 impl From<TaggedProgramInstruction> for RegisterContaining {
     fn from(inst: TaggedProgramInstruction) -> Self {
-        Self(Box::new(inst))
+        RegisterContaining::Unallocated(Box::new(inst))
     }
 }
 
 impl RegisterContaining {
     pub(crate) fn instruction(&self) -> &TaggedProgramInstruction {
-        &self.0
+        match self {
+            RegisterContaining::Unallocated(tpi) => tpi,
+            RegisterContaining::Allocated(_, tpi) => tpi,
+        }
     }
 
     fn symbol_uses(
@@ -383,7 +393,7 @@ impl RegisterContaining {
         // purpose of determining which contexts it has been
         // used in.
         let mut result = Vec::new();
-        for symbol_use in self.0.symbol_uses(block_id, block_offset) {
+        for symbol_use in self.instruction().symbol_uses(block_id, block_offset) {
             let (name, span, symbol_definition) = symbol_use;
             match symbol_definition {
                 def @ SymbolUse::Reference(_) => {

assembler/src/asmlib/driver.rs

@@ -23,8 +23,8 @@ use super::span::*;
 use super::state::NumeralMode;
 use super::symbol::SymbolName;
 use super::symtab::{
-    BadSymbolDefinition, FinalSymbolDefinition, FinalSymbolTable, FinalSymbolType, LookupOperation,
-    SymbolDefinition, SymbolTable,
+    assign_default_rc_word_tags, BadSymbolDefinition, FinalSymbolDefinition, FinalSymbolTable,
+    FinalSymbolType, LookupOperation, SymbolDefinition, SymbolTable,
 };
 use super::types::*;
 use base::prelude::{Address, IndexBy, Unsigned18Bit, Unsigned36Bit};
@@ -471,7 +471,7 @@ fn assemble_pass3(
     };
 
     let Directive {
-        memory_map,
+        mut memory_map,
         equalities,
         entry_point: _,
     } = directive;
@@ -500,6 +500,12 @@ fn assemble_pass3(
         &mut final_symbols,
     )?;
 
+    for (_, directive_block) in memory_map.values_mut() {
+        directive_block.assign_rc_words(symtab, &mut rcblock)?;
+    }
+
+    assign_default_rc_word_tags(symtab, &mut rcblock, &mut final_symbols);
+
     // Emit the binary code.
     for (block_id, (maybe_origin, directive_block)) in memory_map.into_iter() {
         event!(
@@ -542,12 +548,6 @@ fn assemble_pass3(
         };
     }
 
-    // The evaluation process will have resulted in the computation of
-    // a default definition for any symbols which were not already
-    // inserted into final_symbols, so we make sure those are inserted
-    // now.
-    final_symbols.import_default_assigned(&*symtab);
-
     // If the RC-word block is non-empty, emit it.
     if !rcblock.words.is_empty() {
         for (i, (rc_source, word)) in rcblock.words.iter().enumerate() {

assembler/src/asmlib/driver/tests.rs

@@ -703,7 +703,7 @@ fn default_assigned_index_register_easy_case() {
     let program =
         assemble_source("100|STAⱼ 0\nSTAₖ 0\n", Default::default()).expect("program is valid");
     dbg!(&program);
-    assert_eq!(program.chunks.len(), 1);
+    assert_eq!(program.chunks.len(), 1, "wrong number of program chunks");
     assert_eq!(
         SymbolicInstruction::try_from(&Instruction::from(program.chunks[0].words[0]))
             .expect("instruction 09 shoudl be valid"),