Simple assembly language program for theoretical CPU

I'm currently working on a school assignment using a theoretical CPU with a very limited instruction set. The available instructions are as follows:

Code:

add // add registers
addi // add immediate
sub
lui // load upper immediate
and
andi
or
ori
xor
xori
nor
sll // shift left logical
srl // shift right logical
sra // shift right arithmetic
lw // load word
lh // load half word
lb // load byte
sw // store word
sh
sb
beq // branch on equal
bne // branch on not equal
blt // branch on less than
ble // branch on less than or equal
j // jump
jal // jump and link
jr // jump register

Registers are named as r0, r1, ..., r31. One part of the assignment is to write a very simple program for this CPU in assembly language, "such as 1+1=2". I'm an extreme beginner at assembly language and would therefore like to ask for some tips. For example, would the below program work to calculate 1+1? (comments ignored):

addi r1, r0, 1 // add 1 to zero register, store in r1
addi r2, r0, 1 // add 1 to zero register, store in r2
add r3, r2, r1 // add r1 and r2, store in r3
sb r3 0(r1) // store contents of r3 to memory address 1 (r1 = 1 and dpl = 0)

I may be completely off track with this so please tell me if it looks weird. Also, if you have any ideas about slightly more complex programs (that use a branching instruction, for example) I'd greatly appreciate your suggestions.

 

You need to know more than just the keyword to write programs. For example, what does addi a,b,c mean, is it a+b=c, or a=b+c, or b=a+c, or (accumulator)=a+b+c, or *a=*b+*c, or something else?

Are there any details about the CPU posted anywhere; are you using a theoretical one of your own design or a design you got from somewhere?

 

Thanks for the reply. I've added descriptions and syntax below. rs = source register, rt = target register, rd = destination register.

Code:

add // rd <-- rs + rt // R-type
addi // rt <-- rs + imm // I-type
sub // rd <-- rs - rt // R-type
lui // rt <-- imm <<16 (shift) // I-type
and // rd <-- rs AND rt (bitwise) // R-type
andi // rt <-- rs AND imm // I-type
or // rd <-- rs OR rt // R-type
ori // rd <-- rs OR imm // I-type
xor // rd <-- rs XOR rt // R-type
xori // rt <-- rs OR imm // I-type
nor // rd <-- rs NOR rt // R-type
sll // rd <-- rs llshift aux[10, 6] // R-type
srl // rd <-- rs lrshift aux[10, 6] // R-type
sra // rd <-- rs arshift aux[10, 6] // R-type
lw // rt <-- mem(rs + dpl) // I-type
lh
lb
sw // mem(rs + dpl) <-- rt // I-type
sh
sb
beq // if rs == rt then PC = PC + dpl // I-type
bne // if rs !== rt then PC = PC + dpl // I-type
blt // if rs < rt then PC = PC + dpl // I-type
ble // if rs <= rt then PC = PC + dpl // I-type
j // PC <-- addr // A-type
jal // r31 <-- PC + 4; PC <-- addr // A-type
jr // PC <-- rs // R-type

-- SYNTAX --
R-type: <op> rd, rs, rt
I-type: <op> rt, rs, imm
A-type: <op> <addr>

Registers are named as r0, r1, ..., r31. One part of the assignment is to write a very simple program for this CPU in assembly language, "such as 1+1=2". I'm an extreme beginner at assembly language and would therefore like to ask for some tips. For example, would the below program work to calculate 1+1? (comments ignored):

Code:

addi r1, r0, 1 // add 1 to zero register, store in r1
addi r2, r0, 1 // add 1 to zero register, store in r2
add r3, r2, r1 // add r1 and r2, store in r3
sb r3 0(r1) // store contents of r3 to memory address 1 (r1 = 1 and dpl = 0)

I haven't been able to find more details about the CPU design online. It is presented in a textbook for the class I'm taking. I'm currently doing an exchange year in Japan so the textbook is in Japanese and even though I can understand it fairly well it does make things slightly harder. :goofy:

 

I would say probably not, because it depends on the initial value of r0.
If r0 starts off as zero, what do you think the result will be? If you're not sure, take it a step at a time.
What is the result of addi r1,r0,1?
Then when you've worked that out, what is the result of addi r2,r0,1?
And so on. That's how you solve problems like this.

 

Since r0, the zero register, has a constant value 0, my reasoning is that

Code:

addi r1, r0, 1

will add together 0 + 1 (r0 and imm 1) and store the result (=1) in r1. Is this incorrect?

 

Why are you asking if this is incorrect?
What exactly don't you understand about

Code:

addi // rt <-- rs + imm // I-type

Also what happens if you run the program; does it do what you expect?

I'm puzzled about why you want to know in advance what will happen. Experimentation is key to learning and you will develop the skills to perform a dry run in your head only in conjunction with much experimentation. What's the worst that can happen if you just try it and see what happens? If it doesn't do what you expect then you can start to figure out why.

 

Thanks for the feedback.

Perhaps I've explained my problem poorly. This instruction set and its syntax is, afaik, not supported by an actual CPU. It is merely a hypothetical one introduced for this particular assignment. However, one may assume that it accepts the instructions and syntax mentioned above.

I'm only interested in knowing whether my suggested program is a reasonable approach for a program that performs some simple operations, such as 1+1=2. Had it been a high-level programming language, I might have created two variables say x and y, assign x = 1 and let y = x + x, but since I have no previous experience in assembly language I'm not sure how to appropriately represent such operations.

If I wanted to be able to compile and test the program I would need to design the actual CPU, right? Is this doable with only the information given in this thread?

Does this make things any clearer or have I just proven my ignorance? :freak:

 

OK, fair point, I had missed the fact that this CPU doesn't actually exist. So you have no choice but to dry run it in your head. I'm reluctant just to say "yes" or "no" because it's in discovering the answer for yourself that you will learn. But maybe nobody's actually bothered to explain how to dry run a program, so here's how I would do it. We'll assume that r0 starts off at zero:

Initiali register values: r0=0; r1=?; r2=?; r3=? (? means unknown value)

Let's look at the first instruction: addi r1, r0, 1 // add 1 to zero register, store in r1

If this works correctly, the new values of the registers above will be:
r0=0; r1=1; r2=?; r3=?

After addi r2, r0, 1 // add 1 to zero register, store in r2
the registers should contain r0=0; r1=1; r2=1; r3=?

After add r3, r2, r1 // add r1 and r2, store in r3
the registers should contain r0=0; r1=1; r2=1; r3=2

sb r3 0(r1) // store contents of r3 to memory address 1 (r1 = 1 and dpl = 0)
Memory location 1 should now contain the value 2.

(note "should". That comes from many years of experience with computers and finding it's always a good idea to hedge your bets. Feel free to replace this with "will" if you see fit.)

 

Thanks, I feel I've somewhat got the hang of it now. :pleased:

Also, your advice has made me want to try to do more than just a "dry run", so I might start looking into some actual CPU design after this. Thanks again!