add labelalign directive

Author: hlorenzi

src/asm/bank.rs

@@ -6,6 +6,7 @@ pub struct Bank
     pub name: String,
 
     pub wordsize: usize,
+    pub labelalign: usize,
 	pub addr_start: util::BigInt,
 	pub addr_size: Option<usize>,
 	pub output_offset: Option<usize>,
@@ -29,6 +30,7 @@ impl Bank
         Bank {
             name: "".to_string(),
             wordsize: 8,
+            labelalign: 0,
             addr_start: util::BigInt::from(0),
             addr_size: None,
             output_offset: Some(0),

src/asm/parser/addr_related.rs

@@ -1,6 +1,20 @@
 use crate::*;
 
 
+pub fn parse_directive_bits(
+    state: &mut asm::parser::State)
+    -> Result<(), ()>
+{
+    state.asm_state.cur_wordsize = asm::parser::parse_expr_usize_fn(state, |u| match u
+    {
+        0 => None,
+        _ => Some(u)
+    })?;
+
+    Ok(())
+}
+
+
 pub fn parse_directive_res(
     state: &mut asm::parser::State)
     -> Result<(), ()>
@@ -37,6 +51,20 @@ pub fn parse_directive_align(
 }
 
 
+pub fn parse_directive_labelalign(
+    state: &mut asm::parser::State)
+    -> Result<(), ()>
+{
+    state.asm_state.cur_labelalign = asm::parser::parse_expr_usize_fn(state, |u| match u
+    {
+        0 => None,
+        _ => Some(u),
+    })?;
+
+    Ok(())
+}
+
+
 pub fn parse_directive_addr(
     state: &mut asm::parser::State)
     -> Result<(), ()>

src/asm/parser/bank.rs

@@ -21,6 +21,7 @@ pub fn parse_directive_bankdef(
     {
         name: name.clone(),
         wordsize: state.asm_state.cur_wordsize,
+        labelalign: state.asm_state.cur_labelalign,
         addr_start: util::BigInt::from(0),
         addr_size: None,
         output_offset: None,
@@ -88,6 +89,12 @@ fn parse_bankdef_field(
                 _ => Some(u)
             })?,
 
+        "labelalign" => bank.labelalign = asm::parser::parse_expr_usize_fn(state, |u| match u
+            {
+                0 => None,
+                _ => Some(u)
+            })?,
+            
         "fill" => bank.fill = true,
 
         _ =>
@@ -115,6 +122,7 @@ pub fn parse_directive_bank(
 
     let bank = &state.asm_state.banks[state.asm_state.cur_bank.index];
     state.asm_state.cur_wordsize = bank.wordsize;
+    state.asm_state.cur_labelalign = bank.labelalign;
 
     Ok(())
 }

src/asm/parser/file.rs

@@ -107,6 +107,7 @@ pub fn parse_directive(state: &mut asm::parser::State)
             "include" => asm::parser::parse_directive_include(state)?,
             "res" => asm::parser::parse_directive_res(state)?,
             "align" => asm::parser::parse_directive_align(state)?,
+            "labelalign" => asm::parser::parse_directive_labelalign(state)?,
             "addr" => asm::parser::parse_directive_addr(state)?,
             //"enable" => asm::parser::parse_directive_enable(state)?,
             _ =>
@@ -123,20 +124,6 @@ pub fn parse_directive(state: &mut asm::parser::State)
 }
 
 
-pub fn parse_directive_bits(
-    state: &mut asm::parser::State)
-    -> Result<(), ()>
-{
-    state.asm_state.cur_wordsize = asm::parser::parse_expr_usize_fn(state, |u| match u
-    {
-        0 => None,
-        _ => Some(u)
-    })?;
-
-    Ok(())
-}
-
-
 pub fn parse_expr_bigint(state: &mut asm::parser::State) -> Result<(util::BigInt, diagn::Span), ()>
 {
     let expr = expr::Expr::parse(&mut state.parser)?;

src/asm/parser/symbol.rs

@@ -17,11 +17,12 @@ pub fn parse_symbol(
     let tk_name = state.parser.expect(syntax::TokenKind::Identifier)?;
     let name = tk_name.excerpt.clone().unwrap();
     span = span.join(&tk_name.span);
-    
-    let ctx = state.asm_state.get_ctx(state);
+
+    let ctx;
 
     let value = if state.parser.maybe_expect(syntax::TokenKind::Equal).is_some()
     {		
+        ctx = state.asm_state.get_ctx(state);
         let expr = expr::Expr::parse(&mut state.parser)?;
         let value = state.asm_state.eval_expr(
             state.report.clone(),
@@ -36,10 +37,23 @@ pub fn parse_symbol(
     }
     else
     {
+        if state.asm_state.cur_labelalign != 0
+        {
+            println!("{:?}", state.asm_state.cur_labelalign);
+            let bankdata = state.asm_state.get_bankdata(state.asm_state.cur_bank);
+            let skip_bits = bankdata.bits_until_aligned(
+                state.asm_state,
+                state.asm_state.cur_labelalign);
+        
+            let bankdata = state.asm_state.get_bankdata_mut(state.asm_state.cur_bank);
+            bankdata.reserve(skip_bits);
+        }
+
         let tk_colon = state.parser.expect(syntax::TokenKind::Colon)?;
 
         span = span.join(&tk_colon.span);
 
+        ctx = state.asm_state.get_ctx(state);
         let addr = state.asm_state.get_addr(
             state.report.clone(),
             &ctx,

src/asm/state.rs

@@ -18,6 +18,7 @@ pub struct State
 	pub active_rulesets: Vec<RulesetRef>,
 	pub cur_bank: BankRef,
 	pub cur_wordsize: usize,
+	pub cur_labelalign: usize,
 }
 
 
@@ -147,7 +148,6 @@ impl Assembler
 				{
 					//println!("output {:?}, {:x}", bank.output_offset, &bank_output.as_ref().unwrap());
 
-					// FIXME: multiplication by wordsize can overflow
 					full_output.write_bitvec(
 						output_offset,
 						&bank_output.unwrap());
@@ -197,6 +197,7 @@ impl State
 			active_rulesets: Vec::new(),
 			cur_bank: BankRef { index: 0 },
 			cur_wordsize: 8,
+			cur_labelalign: 0,
 		};
 
 		state.create_bank(asm::Bank::new_default(), diagn::RcReport::new()).unwrap();
@@ -321,6 +322,7 @@ impl State
 
 		self.cur_bank = bank_ref;
 		self.cur_wordsize = bank.wordsize;
+		self.cur_labelalign = bank.labelalign;
 
 		self.banks.push(bank);
 

tests/bank_labelalign.asm

@@ -0,0 +1,40 @@
+; ::: include
+
+#ruledef test
+{
+    ld {x} => 0x55 @ x`8
+}
+
+; :::
+
+#labelalign 32
+#bankdef a { #addr 0, #outp 0 }
+ld $ ; = 0x5500
+label: ; = 0x0000
+ld $ ; = 0x5504
+
+; :::
+
+#bankdef a { #addr 0, #outp 0, #labelalign 32 }
+ld $ ; = 0x5500
+label: ; = 0x0000
+ld $ ; = 0x5504
+
+; :::
+
+#labelalign 32
+#bankdef a { #addr 0, #size 8, #outp 0 }
+#labelalign 64
+#bankdef b { #addr 0, #outp 8 * 8 }
+
+#bank a
+ld $
+label1:
+ld $
+
+#bank b
+ld $
+label2:
+ld $
+
+; = 0x5500000055040000_55000000000000005508

tests/labelalign.asm

@@ -0,0 +1,29 @@
+; ::: include
+
+#ruledef test
+{
+    ld {x} => 0x55 @ x`8
+}
+
+; :::
+
+#labelalign 32
+ld $ ; = 0x5500
+label: ; = 0x0000
+ld $ ; = 0x5504
+
+; :::
+
+ld $ ; = 0x5500
+label1:
+ld $ ; = 0x5502
+#labelalign 64
+label2: ; = 0x00000000
+ld $ ; = 0x5508
+
+; :::
+
+#labelalign 33
+ld $
+label: ; error: not aligned
+ld $