ast_printer: emit sega assembly syntax

buhman · buhman · commit 72ae017a18be · 2023-09-03T07:18:23.000Z
diff --git a/ast_printer.cpp b/ast_printer.cpp
@@ -23,7 +23,7 @@ void printer_t::visit(const identifier_t * identifier) const
 
 void printer_t::visit(const literal_t * literal) const
 {
-  os << std::to_string(literal->value);
+  os << "0x" << std::hex << literal->value;
 }
 
 void printer_t::visit(const unary_t * unary) const
@@ -100,142 +100,164 @@ void printer_t::parenthesize(const std::string_view s, const expr_t * a, const e
 void printer_t::visit(const op::andl_t * andl) const
 {
   (void)andl;
-  parenthesize("andl");
+  os << "and";
 }
 
 void printer_t::visit(const op::orl_t * orl) const
 {
   (void)orl;
-  parenthesize("orl");
+  os << "or";
 }
 
 void printer_t::visit(const op::xorl_t * xorl) const
 {
   (void)xorl;
-  parenthesize("xorl");
+  os << "xor";
 }
 
 void printer_t::visit(const op::add_t * add) const
 {
   (void)add;
-  parenthesize("add");
+  os << "add";
 }
 
 void printer_t::visit(const op::sub_t * sub) const
 {
   (void)sub;
-  parenthesize("sub");
+  os << "sub";
 }
 
 void printer_t::visit(const op::ad2_t * ad2) const
 {
   (void)ad2;
-  parenthesize("ad2");
+  os << "ad2";
 }
 
 void printer_t::visit(const op::sr_t * sr) const
 {
   (void)sr;
-  parenthesize("sr");
+  os << "sr";
 }
 
 void printer_t::visit(const op::rr_t * rr) const
 {
   (void)rr;
-  parenthesize("rr");
+  os << "rr";
 }
 
 void printer_t::visit(const op::sl_t * sl) const
 {
   (void)sl;
-  parenthesize("sl");
+  os << "sl";
 }
 
 void printer_t::visit(const op::rl_t * rl) const
 {
   (void)rl;
-  parenthesize("rl");
+  os << "rl";
 }
 
 void printer_t::visit(const op::rl8_t * rl8) const
 {
   (void)rl8;
-  parenthesize("rl8");
+  os << "rl8";
 }
 
 void printer_t::visit(const op::mov_ram_x_t * mov_ram_x) const
 {
-  parenthesize("mov", op::x_src_string[static_cast<int>(mov_ram_x->src.value)], "x");
+  os << "mov"
+     << ' '
+     << op::x_src_string[static_cast<int>(mov_ram_x->src.value)]
+     << ",x";
 }
 
 void printer_t::visit(const op::mov_mul_p_t * mov_mul_p) const
 {
   (void)mov_mul_p;
-  parenthesize("mov mul p");
+  os << "mov mul,p";
 }
 
 void printer_t::visit(const op::mov_ram_p_t * mov_ram_p) const
 {
-  parenthesize("mov", op::x_src_string[static_cast<int>(mov_ram_p->src.value)], "p");
+  os << "mov"
+     << ' '
+     << op::x_src_string[static_cast<int>(mov_ram_p->src.value)]
+     << ",p";
 }
 
 void printer_t::visit(const op::mov_ram_y_t * mov_ram_y) const
 {
-  parenthesize("mov", op::y_src_string[static_cast<int>(mov_ram_y->src.value)], "y");
+  os << "mov"
+     << ' '
+     << op::y_src_string[static_cast<int>(mov_ram_y->src.value)]
+     << ",y";
 }
 
 void printer_t::visit(const op::clr_a_t * clr_a) const
 {
   (void)clr_a;
-  parenthesize("clr a");
+  os << "clr a";
 }
 
 void printer_t::visit(const op::mov_alu_a_t * mov_alu_a) const
 {
   (void)mov_alu_a;
-  parenthesize("mov alu a");
+  os << "mov alu,a";
 }
 
 void printer_t::visit(const op::mov_ram_a_t * mov_ram_a) const
 {
-  parenthesize("mov", op::y_src_string[static_cast<int>(mov_ram_a->src.value)], "a");
+  os << "mov"
+     << ' '
+     << op::y_src_string[static_cast<int>(mov_ram_a->src.value)]
+     << ",a";
 }
 
 void printer_t::visit(const op::mov_imm_d1_t * mov_imm_d1) const
 {
-  parenthesize("mov",
-               mov_imm_d1->imm.expr,
-               op::d1_dst_string[static_cast<int>(mov_imm_d1->dst.value)]);
+  os << "mov"
+     << ' ';
+  mov_imm_d1->imm.expr->accept(this);
+  os << ','
+     << op::d1_dst_string[static_cast<int>(mov_imm_d1->dst.value)];
 }
 
 void printer_t::visit(const op::mov_ram_d1_t * mov_ram_d1) const
 {
-  parenthesize("mov",
-               op::d1_src_string[static_cast<int>(mov_ram_d1->src.value)],
-               op::d1_dst_string[static_cast<int>(mov_ram_d1->dst.value)]);
+  os << "mov"
+     << ' '
+     << op::d1_src_string[static_cast<int>(mov_ram_d1->src.value)]
+     << ','
+     << op::d1_dst_string[static_cast<int>(mov_ram_d1->dst.value)];
 }
 
 void printer_t::visit(const op::control_word_t * control_word) const
 {
-  os << "(control_word ";
-  for (const auto& op : control_word->ops) {
+  for (decltype(control_word->ops)::size_type ix = 0; ix < control_word->ops.size(); ix++) {
+    const auto& op = control_word->ops[ix];
     std::visit([*this](auto&& arg){ (arg).accept(this); }, op);
-    os << ' ';
+    if (ix < (control_word->ops.size() - 1))
+      os << "  ";
   }
-  os << ')';
 }
 
 void printer_t::visit(const load::mvi_t * mvi) const
 {
-  parenthesize("mvi", mvi->imm.expr, load::dst_string[static_cast<int>(mvi->dst.value)]);
+  os << "mvi"
+     << ' ';
+  mvi->imm.expr->accept(this);
+  os << ','
+     << load::dst_string[static_cast<int>(mvi->dst.value)];
 }
 
 void printer_t::visit(const load::mvi_cond_t * mvi_cond) const
 {
-  parenthesize("mvi",
-               mvi_cond->imm.expr,
-               load::dst_string[static_cast<int>(mvi_cond->dst.value)],
-               load::cond_string[static_cast<int>(mvi_cond->cond.value)]);
+  os << "mvi"
+     << ' ';
+  mvi_cond->imm.expr->accept(this);
+  os << ','
+     << load::dst_string[static_cast<int>(mvi_cond->dst.value)]
+     << load::cond_string[static_cast<int>(mvi_cond->cond.value)];
 }
 
 static std::string dma_hold_add(dma::hold_t hold, dma::add_t add)
@@ -246,76 +268,92 @@ static std::string dma_hold_add(dma::hold_t hold, dma::add_t add)
 
 void printer_t::visit(const dma::src_d0_imm_t * src_d0_imm) const
 {
-  parenthesize(dma_hold_add(src_d0_imm->hold, src_d0_imm->add),
-               dma::src_string[static_cast<int>(src_d0_imm->src.value)],
-	       "d0",
-               src_d0_imm->imm.expr);
+  os << dma_hold_add(src_d0_imm->hold, src_d0_imm->add)
+     << ' '
+     << dma::src_string[static_cast<int>(src_d0_imm->src.value)]
+     << ','
+     << "d0"
+     << ',';
+  src_d0_imm->imm.expr->accept(this);
 }
 
 void printer_t::visit(const dma::d0_dst_imm_t * d0_dst_imm) const
 {
-  parenthesize(dma_hold_add(d0_dst_imm->hold, d0_dst_imm->add),
-	       "d0",
-               dma::dst_string[static_cast<int>(d0_dst_imm->dst.value)],
-               d0_dst_imm->imm.expr);
+  os << dma_hold_add(d0_dst_imm->hold, d0_dst_imm->add)
+     << ' '
+     << "d0"
+     << ','
+     << dma::dst_string[static_cast<int>(d0_dst_imm->dst.value)]
+     << ',';
+  d0_dst_imm->imm.expr->accept(this);
 }
 
 void printer_t::visit(const dma::src_d0_ram_t * src_d0_ram) const
 {
-  parenthesize(dma_hold_add(src_d0_ram->hold, src_d0_ram->add),
-               dma::src_string[static_cast<int>(src_d0_ram->src.value)],
-	       "d0",
-               dma::length_ram_string[static_cast<int>(src_d0_ram->ram.value)]);
+  os << dma_hold_add(src_d0_ram->hold, src_d0_ram->add)
+     << ' '
+     << dma::src_string[static_cast<int>(src_d0_ram->src.value)]
+     << ','
+     << "d0"
+     << ','
+     << dma::length_ram_string[static_cast<int>(src_d0_ram->ram.value)];
 }
 
 void printer_t::visit(const dma::d0_dst_ram_t * d0_dst_ram) const
 {
-  parenthesize(dma_hold_add(d0_dst_ram->hold, d0_dst_ram->add),
-	       "d0",
-               dma::dst_string[static_cast<int>(d0_dst_ram->dst.value)],
-               dma::length_ram_string[static_cast<int>(d0_dst_ram->ram.value)]);
+  os << dma_hold_add(d0_dst_ram->hold, d0_dst_ram->add)
+     << ' '
+     << "d0"
+     << ','
+     << dma::dst_string[static_cast<int>(d0_dst_ram->dst.value)]
+     << ','
+     << dma::length_ram_string[static_cast<int>(d0_dst_ram->ram.value)];
 }
 
 void printer_t::visit(const jump::jmp_t * jmp) const
 {
-  parenthesize("jmp", jmp->imm.expr);
+  os << "jmp"
+     << ' ';
+  jmp->imm.expr->accept(this);
 }
 
 void printer_t::visit(const jump::jmp_cond_t * jmp_cond) const
 {
-  parenthesize("jmp",
-	       jump::cond_string[static_cast<int>(jmp_cond->cond.value)],
-	       jmp_cond->imm.expr);
+  os << "jmp"
+     << ' '
+     << jump::cond_string[static_cast<int>(jmp_cond->cond.value)]
+     << ',';
+  jmp_cond->imm.expr->accept(this);
 }
 
 void printer_t::visit(const loop::btm_t * btm) const
 {
   (void)btm;
-  parenthesize("btm");
+  os << "btm";
 }
 
 void printer_t::visit(const loop::lps_t * lps) const
 {
   (void)lps;
-  parenthesize("lps");
+  os << "lps";
 }
 
 void printer_t::visit(const end::end_t * end) const
 {
   (void)end;
-  parenthesize("end");
+  os << "end";
 }
 
 void printer_t::visit(const end::endi_t * endi) const
 {
   (void)endi;
-  parenthesize("endi");
+  os << "endi";
 }
 
 void printer_t::visit(const nop::nop_t * nop) const
 {
   (void)nop;
-  parenthesize("nop");
+  os << "nop";
 }
 
 void printer_t::visit(const assign_t * assign) const
diff --git a/disassemble.cpp b/disassemble.cpp
@@ -25,7 +25,8 @@ static dsp::stmt_t * decompile(uint32_t code)
   using namespace dsp::end;
   using namespace dsp::nop;
 
-  if      (control_word_t::pred(code)) return new control_word_t(code);
+  if      (nop_t::pred(code))          return new nop_t(code);
+  else if (control_word_t::pred(code)) return new control_word_t(code);
   else if (mvi_t::pred(code))          return new mvi_t(code);
   else if (mvi_cond_t::pred(code))     return new mvi_cond_t(code);
   else if (d0_dst_imm_t::pred(code))   return new d0_dst_imm_t(code);
@@ -78,8 +79,6 @@ static int run_file(char const * const input_filename)
 
 int main(const int argc, char const * const argv[])
 {
-  const std::string c_source("-s");
-
   switch (argc) {
   case 2: return run_file(argv[1]);
   default:
diff --git a/stmt.hpp b/stmt.hpp
@@ -19,9 +19,9 @@ struct nop_t : stmt_accept_t<nop_t>, ins_t<nop_t>
     (void)code;
   }
 
-  uint32_t mask() const { return 0xffff'ffff; }
-  uint32_t code() const { return 0x0000'0000; }
-  uint32_t bits() const { return 0;           }
+  static constexpr uint32_t mask() { return 0xffff'ffff; }
+  static constexpr uint32_t code() { return 0x0000'0000; }
+  static constexpr uint32_t bits() { return 0;           }
 };
 
 } // namespace nop

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ void printer_t::visit(const identifier_t * identifier) const`
`23`	`23`
`24`	`24`	`void printer_t::visit(const literal_t * literal) const`
`25`	`25`	`{`
`26`		`- os << std::to_string(literal->value);`
	`26`	`+ os << "0x" << std::hex << literal->value;`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`void printer_t::visit(const unary_t * unary) const`
`@@ -100,142 +100,164 @@ void printer_t::parenthesize(const std::string_view s, const expr_t * a, const e`
`100`	`100`	`void printer_t::visit(const op::andl_t * andl) const`
`101`	`101`	`{`
`102`	`102`	`(void)andl;`
`103`		`- parenthesize("andl");`
	`103`	`+ os << "and";`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`void printer_t::visit(const op::orl_t * orl) const`
`107`	`107`	`{`
`108`	`108`	`(void)orl;`
`109`		`- parenthesize("orl");`
	`109`	`+ os << "or";`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`void printer_t::visit(const op::xorl_t * xorl) const`
`113`	`113`	`{`
`114`	`114`	`(void)xorl;`
`115`		`- parenthesize("xorl");`
	`115`	`+ os << "xor";`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`void printer_t::visit(const op::add_t * add) const`
`119`	`119`	`{`
`120`	`120`	`(void)add;`
`121`		`- parenthesize("add");`
	`121`	`+ os << "add";`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`void printer_t::visit(const op::sub_t * sub) const`
`125`	`125`	`{`
`126`	`126`	`(void)sub;`
`127`		`- parenthesize("sub");`
	`127`	`+ os << "sub";`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`void printer_t::visit(const op::ad2_t * ad2) const`
`131`	`131`	`{`
`132`	`132`	`(void)ad2;`
`133`		`- parenthesize("ad2");`
	`133`	`+ os << "ad2";`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`void printer_t::visit(const op::sr_t * sr) const`
`137`	`137`	`{`
`138`	`138`	`(void)sr;`
`139`		`- parenthesize("sr");`
	`139`	`+ os << "sr";`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`void printer_t::visit(const op::rr_t * rr) const`
`143`	`143`	`{`
`144`	`144`	`(void)rr;`
`145`		`- parenthesize("rr");`
	`145`	`+ os << "rr";`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`void printer_t::visit(const op::sl_t * sl) const`
`149`	`149`	`{`
`150`	`150`	`(void)sl;`
`151`		`- parenthesize("sl");`
	`151`	`+ os << "sl";`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`void printer_t::visit(const op::rl_t * rl) const`
`155`	`155`	`{`
`156`	`156`	`(void)rl;`
`157`		`- parenthesize("rl");`
	`157`	`+ os << "rl";`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`void printer_t::visit(const op::rl8_t * rl8) const`
`161`	`161`	`{`
`162`	`162`	`(void)rl8;`
`163`		`- parenthesize("rl8");`
	`163`	`+ os << "rl8";`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`void printer_t::visit(const op::mov_ram_x_t * mov_ram_x) const`
`167`	`167`	`{`
`168`		`- parenthesize("mov", op::x_src_string[static_cast<int>(mov_ram_x->src.value)], "x");`
	`168`	`+ os << "mov"`
	`169`	`+ << ' '`
	`170`	`+ << op::x_src_string[static_cast<int>(mov_ram_x->src.value)]`
	`171`	`+ << ",x";`
`169`	`172`	`}`
`170`	`173`
`171`	`174`	`void printer_t::visit(const op::mov_mul_p_t * mov_mul_p) const`
`172`	`175`	`{`
`173`	`176`	`(void)mov_mul_p;`
`174`		`- parenthesize("mov mul p");`
	`177`	`+ os << "mov mul,p";`
`175`	`178`	`}`
`176`	`179`
`177`	`180`	`void printer_t::visit(const op::mov_ram_p_t * mov_ram_p) const`
`178`	`181`	`{`
`179`		`- parenthesize("mov", op::x_src_string[static_cast<int>(mov_ram_p->src.value)], "p");`
	`182`	`+ os << "mov"`
	`183`	`+ << ' '`
	`184`	`+ << op::x_src_string[static_cast<int>(mov_ram_p->src.value)]`
	`185`	`+ << ",p";`
`180`	`186`	`}`
`181`	`187`
`182`	`188`	`void printer_t::visit(const op::mov_ram_y_t * mov_ram_y) const`
`183`	`189`	`{`
`184`		`- parenthesize("mov", op::y_src_string[static_cast<int>(mov_ram_y->src.value)], "y");`
	`190`	`+ os << "mov"`
	`191`	`+ << ' '`
	`192`	`+ << op::y_src_string[static_cast<int>(mov_ram_y->src.value)]`
	`193`	`+ << ",y";`
`185`	`194`	`}`
`186`	`195`
`187`	`196`	`void printer_t::visit(const op::clr_a_t * clr_a) const`
`188`	`197`	`{`
`189`	`198`	`(void)clr_a;`
`190`		`- parenthesize("clr a");`
	`199`	`+ os << "clr a";`
`191`	`200`	`}`
`192`	`201`
`193`	`202`	`void printer_t::visit(const op::mov_alu_a_t * mov_alu_a) const`
`194`	`203`	`{`
`195`	`204`	`(void)mov_alu_a;`
`196`		`- parenthesize("mov alu a");`
	`205`	`+ os << "mov alu,a";`
`197`	`206`	`}`
`198`	`207`
`199`	`208`	`void printer_t::visit(const op::mov_ram_a_t * mov_ram_a) const`
`200`	`209`	`{`
`201`		`- parenthesize("mov", op::y_src_string[static_cast<int>(mov_ram_a->src.value)], "a");`
	`210`	`+ os << "mov"`
	`211`	`+ << ' '`
	`212`	`+ << op::y_src_string[static_cast<int>(mov_ram_a->src.value)]`
	`213`	`+ << ",a";`
`202`	`214`	`}`
`203`	`215`
`204`	`216`	`void printer_t::visit(const op::mov_imm_d1_t * mov_imm_d1) const`
`205`	`217`	`{`
`206`		`- parenthesize("mov",`
`207`		`- mov_imm_d1->imm.expr,`
`208`		`- op::d1_dst_string[static_cast<int>(mov_imm_d1->dst.value)]);`
	`218`	`+ os << "mov"`
	`219`	`+ << ' ';`
	`220`	`+ mov_imm_d1->imm.expr->accept(this);`
	`221`	`+ os << ','`
	`222`	`+ << op::d1_dst_string[static_cast<int>(mov_imm_d1->dst.value)];`
`209`	`223`	`}`
`210`	`224`
`211`	`225`	`void printer_t::visit(const op::mov_ram_d1_t * mov_ram_d1) const`
`212`	`226`	`{`
`213`		`- parenthesize("mov",`
`214`		`- op::d1_src_string[static_cast<int>(mov_ram_d1->src.value)],`
`215`		`- op::d1_dst_string[static_cast<int>(mov_ram_d1->dst.value)]);`
	`227`	`+ os << "mov"`
	`228`	`+ << ' '`
	`229`	`+ << op::d1_src_string[static_cast<int>(mov_ram_d1->src.value)]`
	`230`	`+ << ','`
	`231`	`+ << op::d1_dst_string[static_cast<int>(mov_ram_d1->dst.value)];`
`216`	`232`	`}`
`217`	`233`
`218`	`234`	`void printer_t::visit(const op::control_word_t * control_word) const`
`219`	`235`	`{`
`220`		`- os << "(control_word ";`
`221`		`- for (const auto& op : control_word->ops) {`
	`236`	`+ for (decltype(control_word->ops)::size_type ix = 0; ix < control_word->ops.size(); ix++) {`
	`237`	`+ const auto& op = control_word->ops[ix];`
`222`	`238`	`std::visit([*this](auto&& arg){ (arg).accept(this); }, op);`
`223`		`- os << ' ';`
	`239`	`+ if (ix < (control_word->ops.size() - 1))`
	`240`	`+ os << " ";`
`224`	`241`	`}`
`225`		`- os << ')';`
`226`	`242`	`}`
`227`	`243`
`228`	`244`	`void printer_t::visit(const load::mvi_t * mvi) const`
`229`	`245`	`{`
`230`		`- parenthesize("mvi", mvi->imm.expr, load::dst_string[static_cast<int>(mvi->dst.value)]);`
	`246`	`+ os << "mvi"`
	`247`	`+ << ' ';`
	`248`	`+ mvi->imm.expr->accept(this);`
	`249`	`+ os << ','`
	`250`	`+ << load::dst_string[static_cast<int>(mvi->dst.value)];`
`231`	`251`	`}`
`232`	`252`
`233`	`253`	`void printer_t::visit(const load::mvi_cond_t * mvi_cond) const`
`234`	`254`	`{`
`235`		`- parenthesize("mvi",`
`236`		`- mvi_cond->imm.expr,`
`237`		`- load::dst_string[static_cast<int>(mvi_cond->dst.value)],`
`238`		`- load::cond_string[static_cast<int>(mvi_cond->cond.value)]);`
	`255`	`+ os << "mvi"`
	`256`	`+ << ' ';`
	`257`	`+ mvi_cond->imm.expr->accept(this);`
	`258`	`+ os << ','`
	`259`	`+ << load::dst_string[static_cast<int>(mvi_cond->dst.value)]`
	`260`	`+ << load::cond_string[static_cast<int>(mvi_cond->cond.value)];`
`239`	`261`	`}`
`240`	`262`
`241`	`263`	`static std::string dma_hold_add(dma::hold_t hold, dma::add_t add)`
`@@ -246,76 +268,92 @@ static std::string dma_hold_add(dma::hold_t hold, dma::add_t add)`
`246`	`268`
`247`	`269`	`void printer_t::visit(const dma::src_d0_imm_t * src_d0_imm) const`
`248`	`270`	`{`
`249`		`- parenthesize(dma_hold_add(src_d0_imm->hold, src_d0_imm->add),`
`250`		`- dma::src_string[static_cast<int>(src_d0_imm->src.value)],`
`251`		`- "d0",`
`252`		`- src_d0_imm->imm.expr);`
	`271`	`+ os << dma_hold_add(src_d0_imm->hold, src_d0_imm->add)`
	`272`	`+ << ' '`
	`273`	`+ << dma::src_string[static_cast<int>(src_d0_imm->src.value)]`
	`274`	`+ << ','`
	`275`	`+ << "d0"`
	`276`	`+ << ',';`
	`277`	`+ src_d0_imm->imm.expr->accept(this);`
`253`	`278`	`}`
`254`	`279`
`255`	`280`	`void printer_t::visit(const dma::d0_dst_imm_t * d0_dst_imm) const`
`256`	`281`	`{`
`257`		`- parenthesize(dma_hold_add(d0_dst_imm->hold, d0_dst_imm->add),`
`258`		`- "d0",`
`259`		`- dma::dst_string[static_cast<int>(d0_dst_imm->dst.value)],`
`260`		`- d0_dst_imm->imm.expr);`
	`282`	`+ os << dma_hold_add(d0_dst_imm->hold, d0_dst_imm->add)`
	`283`	`+ << ' '`
	`284`	`+ << "d0"`
	`285`	`+ << ','`
	`286`	`+ << dma::dst_string[static_cast<int>(d0_dst_imm->dst.value)]`
	`287`	`+ << ',';`
	`288`	`+ d0_dst_imm->imm.expr->accept(this);`
`261`	`289`	`}`
`262`	`290`
`263`	`291`	`void printer_t::visit(const dma::src_d0_ram_t * src_d0_ram) const`
`264`	`292`	`{`
`265`		`- parenthesize(dma_hold_add(src_d0_ram->hold, src_d0_ram->add),`
`266`		`- dma::src_string[static_cast<int>(src_d0_ram->src.value)],`
`267`		`- "d0",`
`268`		`- dma::length_ram_string[static_cast<int>(src_d0_ram->ram.value)]);`
	`293`	`+ os << dma_hold_add(src_d0_ram->hold, src_d0_ram->add)`
	`294`	`+ << ' '`
	`295`	`+ << dma::src_string[static_cast<int>(src_d0_ram->src.value)]`
	`296`	`+ << ','`
	`297`	`+ << "d0"`
	`298`	`+ << ','`
	`299`	`+ << dma::length_ram_string[static_cast<int>(src_d0_ram->ram.value)];`
`269`	`300`	`}`
`270`	`301`
`271`	`302`	`void printer_t::visit(const dma::d0_dst_ram_t * d0_dst_ram) const`
`272`	`303`	`{`
`273`		`- parenthesize(dma_hold_add(d0_dst_ram->hold, d0_dst_ram->add),`
`274`		`- "d0",`
`275`		`- dma::dst_string[static_cast<int>(d0_dst_ram->dst.value)],`
`276`		`- dma::length_ram_string[static_cast<int>(d0_dst_ram->ram.value)]);`
	`304`	`+ os << dma_hold_add(d0_dst_ram->hold, d0_dst_ram->add)`
	`305`	`+ << ' '`
	`306`	`+ << "d0"`
	`307`	`+ << ','`
	`308`	`+ << dma::dst_string[static_cast<int>(d0_dst_ram->dst.value)]`
	`309`	`+ << ','`
	`310`	`+ << dma::length_ram_string[static_cast<int>(d0_dst_ram->ram.value)];`
`277`	`311`	`}`
`278`	`312`
`279`	`313`	`void printer_t::visit(const jump::jmp_t * jmp) const`
`280`	`314`	`{`
`281`		`- parenthesize("jmp", jmp->imm.expr);`
	`315`	`+ os << "jmp"`
	`316`	`+ << ' ';`
	`317`	`+ jmp->imm.expr->accept(this);`
`282`	`318`	`}`
`283`	`319`
`284`	`320`	`void printer_t::visit(const jump::jmp_cond_t * jmp_cond) const`
`285`	`321`	`{`
`286`		`- parenthesize("jmp",`
`287`		`- jump::cond_string[static_cast<int>(jmp_cond->cond.value)],`
`288`		`- jmp_cond->imm.expr);`
	`322`	`+ os << "jmp"`
	`323`	`+ << ' '`
	`324`	`+ << jump::cond_string[static_cast<int>(jmp_cond->cond.value)]`
	`325`	`+ << ',';`
	`326`	`+ jmp_cond->imm.expr->accept(this);`
`289`	`327`	`}`
`290`	`328`
`291`	`329`	`void printer_t::visit(const loop::btm_t * btm) const`
`292`	`330`	`{`
`293`	`331`	`(void)btm;`
`294`		`- parenthesize("btm");`
	`332`	`+ os << "btm";`
`295`	`333`	`}`
`296`	`334`
`297`	`335`	`void printer_t::visit(const loop::lps_t * lps) const`
`298`	`336`	`{`
`299`	`337`	`(void)lps;`
`300`		`- parenthesize("lps");`
	`338`	`+ os << "lps";`
`301`	`339`	`}`
`302`	`340`
`303`	`341`	`void printer_t::visit(const end::end_t * end) const`
`304`	`342`	`{`
`305`	`343`	`(void)end;`
`306`		`- parenthesize("end");`
	`344`	`+ os << "end";`
`307`	`345`	`}`
`308`	`346`
`309`	`347`	`void printer_t::visit(const end::endi_t * endi) const`
`310`	`348`	`{`
`311`	`349`	`(void)endi;`
`312`		`- parenthesize("endi");`
	`350`	`+ os << "endi";`
`313`	`351`	`}`
`314`	`352`
`315`	`353`	`void printer_t::visit(const nop::nop_t * nop) const`
`316`	`354`	`{`
`317`	`355`	`(void)nop;`
`318`		`- parenthesize("nop");`
	`356`	`+ os << "nop";`
`319`	`357`	`}`
`320`	`358`
`321`	`359`	`void printer_t::visit(const assign_t * assign) const`