blocks|key|5046529|text|我不知道你是如何在6502上做到这一点的，但是switches通常被编译成jump+tables。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5046530|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Branch_table^0|N|6|11|B|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

I don't know how you'd do this on a 6502, but <code>switch</code>es are often compiled into <a href="https://en.wikipedia.org/wiki/Branch_table" rel="nofollow">jump tables</a>.

blocks|key|4564068|text|实际上，没有更好的方法，但可能会有改进，比如将FlowControl作为子例程调用，然后返回RTS。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4564069|这是主要的流程。|4564070|++jsr+ControlFlow
++;+main+routine+continues+here|code-block|syntax|javascript|4564071|下面是子例程。|4564072|ControlFlow:
++lda+mem
++cmp+#1
++bne+.sub_one
++cmp+#2
++bne+.sub_two
++cmp+#3
++bne+.sub_three
++++;+case+else+here
++rts

++.sub_one:
++++;+sub+routine+one+goes+here
++rts

++.sub_two:
+++;+sub+routine+two+goes+here
++rts

++.sub_three:
+++;+sub+routine+three+goes+here
++rts|4564073|如果子例程太长，则需要使用前面提到的JMPs。|4564074|.jump_to_sub_one
++jmp+.sub_one
.jump_to_sub_two
++jmp+.sub_two
.jump_to_sub_three
++jmp+.sub_three

ControlFlow:
++lda+mem
++cmp+#1
++bne+.jump_to_sub_one
++cmp+#2
++bne+.jump_to_sub_two
++cmp+#3
++bne+.jump_to_sub_three
++++;+case+else+here
++rts

++.sub_one:
++++;+sub+routine+one+goes+here
++rts

++.sub_two:
+++;+sub+routine+two+goes+here
++rts

++.sub_three:
+++;+sub+routine+three+goes+here
++rts|4564075|这就是它是如何完成的，不幸的是，没有更好的方法。这适用于许多汇编语言，如果不是全部的话。|4564076|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

There is no better way actually but there might be an improvement like calling the FlowControl as a subroutine and returning with RTS.

This is the main flow.

<pre><code> jsr ControlFlow
 ; main routine continues here
</code></pre>

Here is the sub routine.

<pre><code>ControlFlow:
 lda mem
 cmp #1
 bne .sub_one
 cmp #2
 bne .sub_two
 cmp #3
 bne .sub_three
 ; case else here
 rts

 .sub_one:
 ; sub routine one goes here
 rts

 .sub_two:
 ; sub routine two goes here
 rts

 .sub_three:
 ; sub routine three goes here
 rts
</code></pre>

if sub routines are too long, you need to use JMPs as mentioned before.

<pre><code>.jump_to_sub_one
 jmp .sub_one
.jump_to_sub_two
 jmp .sub_two
.jump_to_sub_three
 jmp .sub_three

ControlFlow:
 lda mem
 cmp #1
 bne .jump_to_sub_one
 cmp #2
 bne .jump_to_sub_two
 cmp #3
 bne .jump_to_sub_three
 ; case else here
 rts

 .sub_one:
 ; sub routine one goes here
 rts

 .sub_two:
 ; sub routine two goes here
 rts

 .sub_three:
 ; sub routine three goes here
 rts
</code></pre>

That's how it is done and unfortunately, there is no better way. This applies to many assembly languages if not all.

blocks|key|4564140|text|如果案例的数量足够大，跳转表可能会很有用。在左边，有一个跳转到标签的模板(未测试)，它将正确的地址推送到堆栈并返回。在右边有一个基于jsr的比较例程，它将在从每个子例程返回后在标签_out:处继续。进位逻辑在6502上反转，这意味着进位将被设置为if+(Acc+>=+Imm)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4564141|;+goto++label[n]+++vs.+++++++++call+label[n]

lda+variable
cmp+#MAX_PLUS_ONE++++++++++++++++++++++++++
bcs+_out
tax
lda+table_hi,+X
pha++++++++++++++++vs.+++++++++sta+jsrcmd%2B2
lda+table_lo,+X
pha++++++++++++++++vs.+++++++++sta+jsrcmd%2B1
rts++++++++++++++++vs.+jsrcmd:+jsr+1000++++++++;+self+modify

_out:++|code-block|syntax|javascript|4564142|entityMap^0|2I|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Jump tables can be useful, if the number of cases is large enough.
On the left, there's a template (untested) for jump to label that pushes the correct address to stack and returns. On the right there's a diff to jsr based routine, that will continue at the label <code>_out:</code> after returning from each subroutine.
The carry logic is inverted on 6502, meaning that carry will be set if (Acc >= Imm).

<pre><code>; goto label[n] vs. call label[n]

lda variable
cmp #MAX_PLUS_ONE 
bcs _out
tax
lda table_hi, X
pha vs. sta jsrcmd+2
lda table_lo, X
pha vs. sta jsrcmd+1
rts vs. jsrcmd: jsr 1000 ; self modify

_out: 
</code></pre>

blocks|key|370552|text|我在http://wilsonminesco.com/StructureMacros/index.html上有一篇关于在6502汇编中使用宏来构建程序结构的文章。我也为PIC做了这件事，两者的源代码都有链接。当我完成一个我正在做的项目时，会有更多的补充。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|370553|OP对于IF...ELSE...END_IF来说是一个完美的情况。当需要更多的情况时，如果数字是连续的，跳转表工作得很好，并且您不必测试限制，以避免从表外间接跳转和崩溃。除此之外，CASE语句也能很好地工作。http://forum.6502.org/viewtopic.php?f=2&t=2311&start=15是这种讨论的第二页，我将在这里向您展示如何在同一个CASE语句中测试单个情况、一组数字或一组分散的数字。我还没有把RANGE_OF和SET_OF写成6502汇编宏。我只在Forth里有两个。|370554|当然，这些宏的目标是更好地控制代码，使代码更加清晰，并摆脱大量的标签和跳转，这些标签和跳转通常是汇编代码的特征。宏允许您完全控制汇编器放置的每一小块代码，但您不必一直查看内部细节。在大多数情况下，程序内存占用或执行速度的损失绝对为零。你可以获得汇编语言的性能，同时也获得了高级语言的很多好处。代码开发变得更快，更无bug，更易于维护，这意味着当您决定添加功能或更改某些内容时，稍后返回并弄清楚您所做的事情变得更容易。|370555|entityMap|0|LINK|mutability|MUTABLE|url|http://wilsonminesco.com/StructureMacros/index.html|1|http://forum.6502.org/viewtopic.php?f=2&t=2311&start=15^0|2|1F|0|0|2W|1J|1|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

I have an article on using macros to make program structures in 6502 assembly, at <a href="http://wilsonminesco.com/StructureMacros/index.html" rel="nofollow">http://wilsonminesco.com/StructureMacros/index.html</a> . I've done it for PIC also, and the links are there for the source code for both. Further additions are coming when I finish a project I'm working on.

The OP is a perfect situation for IF...ELSE...END_IF. When more cases are desired, the jump table works well if the numbers are consecutive and you don't have to test for limits to avoid jumping indirect from outside the table and crashing. Otherwise a CASE statement works nicely. <a href="http://forum.6502.org/viewtopic.php?f=2&amp;t=2311&amp;start=15" rel="nofollow">http://forum.6502.org/viewtopic.php?f=2&amp;t=2311&amp;start=15</a> is the second page of such a discussion, and I show there how you could test for individual cases, a range of numbers, or a scattering of numbers, all in the same CASE statement. I don't have RANGE_OF and SET_OF written yet as 6502 assembly macros. Those are two I only have in Forth.

The goal of these macros of course is to get better control of code by making it much more clear what you're doing, and getting rid of the mass of labels and jumps that commonly characterize assembly code. The macros let you keep full control of every speck of code laid down by the assembler, but you don't have to keep looking at the internal details. In most cases there is absolutely zero penalty in program memory taken or in execution speed. You get the performance of assembly with a lot of the benefits of higher-level languages. Code becomes quicker to develop, more bug-free, and easier to maintain, meaning that it's easier to come back later and figure out what you did when you decide to add a feature or change something.

blocks|key|5046795|text|6502提供以下控制程序流程，即修改PC寄存器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5046796|5046797|JMP+absolute|unordered-list-item|5046798|JMP+indirect|5046799|Bxx+relative+instructions|5046800|JSR+absolute与较新的RTS|5046801|BRK或具有较晚RTI的其他|5046802|(或RTS，如果将stack)|5046803|Pushing中的两个值拉到堆栈，然后RTS/RTI|5046804|Hardware+.P导致跳过重置向量<代码>H215<代码>F216|offset|length|style|CODE|5046805|5046806|就这样。如果你想要更复杂的东西，你需要使用上面的一个或多个来创建它。|5046807|实现switch语句的一种方法是首先创建一个指针表，指向switch语句中涉及的所有例程。根据例程的低位字节和高位字节对它们进行拆分：|5046808|switchtab_lo+++.db+>routine1,+>routine2,+>routine3|5046809|switchtab_hi+++.db+<routine1,+<routine2,+<routine3|5046810|(我永远记不住>表示低字节还是高字节，不同的汇编程序可能有不同的语法)|5046811|然后，假设您想要切换的值是.X格式的，并且vector是两个不从页面末尾开始的字节(为了避免JMP间接错误)，并且您已经确保它是一个有效的值：|5046812|lda+switchtab_lo,X
sta+vector
lda+switchtab_hi,X
sta+vector%2B1
jmp+(vector)|code-block|syntax|javascript|5046813|每次需要切换时这样做都很乏味，但这就是为什么高级语言被发明出来的原因。|5046814|entityMap^0|0|0|0|0|0|0|0|0|0|9|2|0|0|0|0|0|1E|0|0|1E|0|0|L|6|0|0|0^^$0|@$1|2|3|4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1L|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1M|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|1N|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|1O|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|1P|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|P|3|Q|5|E|7|1R|8|@]|9|@]|A|$]]|$1|R|3|S|5|E|7|1S|8|@$T|1T|U|1U|V|W]]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1W|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1X|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1Y|8|@$T|1Z|U|20|V|W]]|9|@]|A|$]]|$1|14|3|15|5|6|7|21|8|@$T|22|U|23|V|W]]|9|@]|A|$]]|$1|16|3|17|5|6|7|24|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|25|8|@$T|26|U|27|V|W]]|9|@]|A|$]]|$1|1A|3|1B|5|1C|7|28|8|@]|9|@]|A|$1D|1E]]|$1|1F|3|1G|5|6|7|29|8|@]|9|@]|A|$]]|$1|1H|3|-4|5|6|7|2A|8|@]|9|@]|A|$]]]|1I|$]]

6502 provides the following to control program flow, i.e. modify the PC register.

<ul>
<li>JMP absolute</li>
<li>JMP indirect</li>
<li>Bxx relative instructions</li>
<li>JSR absolute with a later RTS</li>
<li>BRK or other IRQ with a later RTI (or RTS if you pull <code>.P</code> off the stack)</li>
<li>Pushing two values to the stack and then RTS/RTI</li>
<li>Hardware reset causes jump through the reset vector</li>
</ul>

That's it. If you want anything more complicated you need to create it using one or more of the above.

One way to implement a switch statement is to first create a table of pointers to all routines involved in the switch statement. Split them according to the low bytes of the routines and then the high bytes:

<code>switchtab_lo .db &gt;routine1, &gt;routine2, &gt;routine3</code>

<code>switchtab_hi .db &lt;routine1, &lt;routine2, &lt;routine3</code>

(I can never remember if > means low byte or high byte and different assemblers may have different syntax)

and then, assuming the value you want to switch upon is in .X, and that <code>vector</code> is two bytes that don't start at the end of the page (to avoid the JMP indirect bug) and you've made sure it's a valid value:

<pre><code>lda switchtab_lo,X
sta vector
lda switchtab_hi,X
sta vector+1
jmp (vector)
</code></pre>

It's tedious to do this each time you need to switch but that's why high level languages were invented.

blocks|key|5046853|text|CMOS6502(即65c02)还具有JMP(abs，X)寻址模式，因此您可以在A中接受输入，使用ASL+A左移1位(因为表中的每个地址都有两个位置)，然后将其传输到X并执行Addr_Table(abs，X)。简单多了。这是在CMOS版本中添加的许多操作码之一。(+CMOS版本还修复了NMOS版本的所有错误)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5046854|entityMap^0|J|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

The CMOS 6502 (ie, 65c02) also has the JMP(abs,X) addressing mode, so you can take the input in A, shift left 1 bit with ASL A, (because each address in the table takes two locations), then transfer it to X and do the JMP(Addr_Table,X). Much simpler. This is one of many op-code additions made in the CMOS version. (The CMOS version also fixed all the bugs of the NMOS version).

blocks|key|370613|text|++++++++lda+mem
++++++++asl
++++++++sta+jump%2B1
jump++++jmp+(vector)

;should+be+page+aligned
vector
++++++++!word+func1,+func2,+func3,+func4|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|370614|如果向量列表不对齐，on需要将索引*2添加到整个向量地址，速度较慢，但内存效率更高。|unstyled|370615|其他选项包括：|370616|+++++++++lda+mem
+++++++++asl
+++++++++clc
+++++++++adc+mem++++++++;we+assume+it+does+not+overflow,+so+carry+stays+cleared
+++++++++sta+branch%2B1+++;mem+*+3
branch+++bcc+*
+++++++++jmp+func1
+++++++++jmp+func2
+++++++++jmp+func3
+++++++++jmp+...|370617|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code> lda mem
 asl
 sta jump+1
jump jmp (vector)

;should be page aligned
vector
 !word func1, func2, func3, func4
</code></pre>

if the list of vectors is not aligned, on needs to add the index*2 to the whole vector address, slower, but more memory efficient.

other options would be:

<pre><code> lda mem
 asl
 clc
 adc mem ;we assume it does not overflow, so carry stays cleared
 sta branch+1 ;mem * 3
branch bcc *
 jmp func1
 jmp func2
 jmp func3
 jmp ...
</code></pre>

I am trying to understand control flow in 6502 assembly.

Say I have the following code:

<pre><code> ControlFlow:
 lda mem
 cmp #1
 bne .sub_one

 cmp #2
 bne .sub_two

 .sub_one:
 ; sub routine one goes here
 jmp .done ; &lt;-------------- without this jmp, .sub_two will execute

 .sub_two:
 ; sub routine two goes here

 .done:

 rts
</code></pre>

Personally, I would love a switch statement or some other control flow structure.
The JMP above concerns me as well. It seems like there is a better way to handle 
multiple cases without this type of spaghetti code.

What methods for using control flow are there in 6502?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试理解6502汇编中的控制流。假设我有以下代码：    ControlFlow:      lda mem      cmp #1      bne .sub_one      cmp #2      bne .sub_two      .sub_one:        ; sub routine one go...

问6502中有哪些使用控制流的方法？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问6502中有哪些使用控制流的方法？EN