Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

Introduction To Assembly Language and RISC-V Instruction Set Architecture

Download as pdf or txt
Download as pdf or txt
You are on page 1of 52

Computer Science 61C Spring 2019 Weaver

Introduction to Assembly Language


and RISC-V Instruction Set
Architecture

1
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

2
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

3
Levels of Representation/Interpretation

Computer Science 61C Spring 2019 Weaver


temp = v[k];
lw $t0, 0($2) High Level Language
 v[k] = v[k+1];
lw $t1, 4($2) Program (e.g., C) v[k+1] = temp;
sw $t1, 0($2)
sw $t0, 4($2) Compiler
Anything can be represented

Assembly Language as a number, 

Program (e.g., MIPS) i.e., data or instructions
Assembler 0000 1001 1100 0110 1010 1111 0101 1000
Machine Language 1010 1111 0101 1000 0000 1001 1100 0110
Program (MIPS) 1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111

Machine
Interpretation

Hardware Architecture Description



(e.g., block diagrams)

Architecture
Implementation

Logic Circuit Description



(Circuit Schematic Diagrams) 4
Instruction Set Architecture (ISA)

Computer Science 61C Spring 2019 Weaver

• Job of a CPU (Central Processing Unit, aka Core): execute instructions

• Instructions: CPU’s primitives operations

• Instructions performed one after another in sequence

• Each instruction does a small amount of work (a tiny part of a larger program).

• Each instruction has an operation applied to operands,

• and might be used change the sequence of instruction.

• CPUs belong to “families,” each implementing its own set of


instructions

• CPU’s particular set of instructions implements an Instruction Set


Architecture (ISA)

• Examples: ARM, Intel x86, MIPS, RISC-V, IBM/Motorola PowerPC (old Mac), Intel IA64, ...
5
Assembly Language Programming ARM

Computer Science 61C Spring 2019 Weaver

• Each assembly language is tied to a particular ISA (its


just a human readable version of machine language).
x86
• Why program in assembly language versus a high-level
language?

• Back in the day, when ISAs where complex and compilers where
immature …. hand optimized assembly code could beat what the
compiler could generate.

• These days ISAs are simple and compilers beat humans

• Assembly language still used in small parts of the OS kernel to access


special hardware resources

• For us … learn to program in assembly language

• Best way to understand what compilers do to generate machine code

• Best way to understand what the CPU hardware does


6
And

Roadmap To Future Classes...
Computer Science 61C Spring 2019 Weaver

• CS164: Compilers

• All the processes in going from source code to assembly

• CS162: O/S

• OS often needs a small amount of assembly for doing things the "high level"
language doesn't support

• Such as accessing special resources

• CS152: Computer Architecture

• How to build the computer that supports the assembly

• CS161: Security

• Exploit code ("shell code") is often in assembly and exploitation often requires
understanding the assembly language of the target.
7
RISC-V

Green Card
Computer Science 61C Spring 2019 Weaver

1/26/18
http://inst.eecs.berkeley.edu/~cs61c/resources/RISCV_Green_Sheet.pdf 8
Inspired by the IBM 360 

“Green Card”
Computer Science 61C Spring 2019 Weaver

9
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

10
What is RISC-V?

Computer Science 61C Spring 2019 Weaver

• Fifth generation of RISC design from UC Berkeley

• A high-quality, license-free, royalty-free RISC ISA specification

• Implementors do not pay any royalties

• But see Amdahl's Law:



A decent 180 MHz 32b ARM chip costs $6 in quantity

A Raspberry Pi (with a 1.2 GHz, quad core ARM and everything else) is $35:

Licensing cost for the ISA can be in the noise

• Experiencing rapid uptake in both industry and academia

• Supported by growing shared software ecosystem

• Appropriate for all levels of computing system, from micro-controllers to


supercomputers

• 32-bit, 64-bit, and 128-bit variants

• (we’re using 32-bit in class, textbook uses 64-bit)

• Standard maintained by non-profit RISC-V Foundation


11
Foundation Members (60+)

Computer Science 61C Spring 2019 Weaver

Platinum:

Gold, Silver, Auditors:

Rumble
12
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

13
Assembly Variables: Registers

Computer Science 61C Spring 2019 Weaver

• Unlike HLL like C or Java, assembly does not have variables


as you know and love them

• More primitive, instead what simple CPU hardware can directly support

• Assembly language operands are objects called registers

• Limited number of special places to hold values, built directly into the hardware

• Arithmetic operations can only be performed on these in a RISC!

• Only memory actions are loads & stores

• CISC can also perform operations on things pointed to by registerst

• Benefit:

• Since registers are directly in hardware, they are very fast to access
14
Registers live inside the Processor

Computer Science 61C Spring 2019 Weaver

Processor Memory
Enable?
Input
Control Read/Write
Data
Datapath
Address
PC Bytes
Register Write
Data
Arithmetic & Logic Unit

s
(ALU)
Read
Data
Program Output

Processor-Memory Interface I/O-Memory Interfaces


15
Speed of Registers vs. Memory

Computer Science 61C Spring 2019 Weaver

• Given that

• Registers: 32 words (128 Bytes)

• Memory (DRAM): Billions of bytes (2 GB to 8 GB on laptop)

• and physics dictates…

• Smaller is faster

• How much faster are registers than DRAM??

• About 100-500 times faster!

• in terms of latency of one access

16
Number of RISC-V Registers

Computer Science 61C Spring 2019 Weaver

• Drawback: Registers are in hardware. To keep them really fast, their


number is limited:

• Solution: RISC-V code must be carefully written to use registers efficiently

• 32 registers in RISC-V, referred to by number x0 – x31

• Registers are also given symbolic names, described later

• Why 32? Smaller is faster, but too small is bad.

• Plus need to be able to specify 3 registers in operations...

• Each RISC-V register is 32 bits wide (RV32 variant of RISC-V ISA)

• Groups of 32 bits called a word in RISC-V ISA

• P&H CoD textbook uses the 64-bit variant RV64 (explain differences later)

• x0 is special, always holds value zero

• So really only 31 registers able to hold variable values


17
C, Java Variables vs. Registers

Computer Science 61C Spring 2019 Weaver

• In C (and most HLLs):

• Variables declared and given a type

• Example:

int fahr, celsius; 

char a, b, c, d, e;

• Each variable can ONLY represent a value of the type it was declared (e.g., cannot
mix and match int and char variables)

• If types are not declared, the object carries around the type with it. EG in python:

a = "fubar" # now a is a string

a = 121 # now a is an integer

• In Assembly Language:

• Registers have no type;

• Operation determines how register contents are interpreted


18
RISC-V Memory Alignment...

Computer Science 61C Spring 2019 Weaver

• RISC-V does not require that integers be word aligned...

• But it is very very bad if you don't make sure they are...

• Consequences of unaligned integers

• Slowdown: The processor is allowed to be a lot slower when it happens

• In fact, a RISC-V processor may natively only support aligned accesses, and do
unaligned-access in software!

An unaligned load could take hundreds of times longer!

• Lack of atomicity: The whole thing doesn't happen at once...



can introduce lots of very subtle bugs

19
RISC-V Instructions

Computer Science 61C Spring 2019 Weaver

• Instructions are fixed, 32b long

• Must be word aligned, or half-word aligned if the 16b optional (C) instruction set is also
enabled

• Only a few formats (we'll go into detail later)...

20
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

21
RISC-V Instruction Assembly Syntax

Computer Science 61C Spring 2019 Weaver

• Instructions have an opcode and operands

E.g., add x1, x2, x3 # x1 = x2 + x3


# is assembly comment syntax
Destination register Second operand register
Operation code (opcode) First operand register

22
Addition and Subtraction of Integers
Computer Science 61C Spring 2019 Weaver

• Addition in Assembly

• Example: add x1,x2,x3 (in RISC-V)

• Equivalent to: a = b + c (in C)

where C variables RISC-V registers are:

a x1, b x2, c x3
• Subtraction in Assembly

• Example: sub x3,x4,x5 (in RISC-V)

• Equivalent to: d = e - f (in C)

where C variables RISC-V registers are:



d x3, e x4, f x5
23
No-Op

Computer Science 61C Spring 2019 Weaver

• A No-op is an instruction that does nothing...

• Why?

You may need to replace code later: No-ops can fill space, align data, and perform
other options

• By convention RISC-V has a specific no-op instruction...

• add x0 x0 x0
• Why?

• Writes to x0 are always ignored...



RISC-V uses that a lot as we will see in the jump-and-link operations

• Making a "standard" no-op improves the disassembler and can potentially improve the
processor

• Special case the particular conventional no-op.


24
Addition and Subtraction of Integers
Example 1 Weaver
Computer Science 61C Spring 2019

• How to do the following C statement?

a = b + c + d - e;

• Break into multiple instructions

add x1, x2, x3 # temp = b + c


add x1, x1, x4 # temp = temp + d
sub x1, x1, x5 # a = temp - e
• A single line of C may turn into several RISC-V instructions
add x3,x4,x0 (in RISC-V) same
f = g (in C)
25
Immediates
Computer Science 61C Spring 2019 Weaver

• Immediates are used to provide numerical constants


• Constants appear often in code, so there are special instructions
for them:

• Ex: Add Immediate:

addi x3,x4,-10 (in RISC-V)

f = g - 10 (in C)

where RISC-V registers x3,x4 are associated with C variables f, g

• Syntax similar to add instruction, except that last argument is a


number instead of a register
addi x3,x4,0 (in RISC-V) same as
f = g (in C) 26
Immediates & Sign Extension...

Computer Science 61C Spring 2019 Weaver

• Immediates are necessarily small

• An I-type instruction can only have 12 bits of immediate

• In RISC-V immediates are "sign extended"

• So the upper bits are the same as the largest bit

• So for a 12b immediate...

• Bits 31:12 get the same value as Bit 11

27
Data Transfer:

Load from and Store to memory Weaver
Computer Science 61C Spring 2019

Processor Memory
Enable?
Input
Read/Write
Control
Data
Datapath Address Much larger place

PC Bytes To hold values, but


Write Data =
slower than registers!
Registers Store to memory

Arithmetic & Logic Unit


Read Data =
(ALU) Load from Program Output
memory

Fast but limited place

To hold values Processor-Memory Interface I/O-Memory Interfaces


28
Memory Addresses are in Bytes

Computer Science 61C Spring 2019 Weaver

• Data typically smaller than 32 bits, but Least-significant byte in word


rarely smaller than 8 bits (e.g., char type)

• So everything is a multiple of 8 bits

• Remember, 8 bit chunk is called a byte



(1 word = 4 bytes)
15 14 13 12
• Memory addresses are really
 11 10 9 8
in bytes, not words

7 6 5 4
• Word addresses are 4 bytes 
 3 2 1 0
apart
31 24 23 16 15 8 7 0
• Word address is same as address of 

rightmost byte – least-significant byte
 Least-significant byte

(i.e. Little-endian convention) gets the smallest address

29
Transfer from Memory to Register

Computer Science 61C Spring 2019 Weaver

• C code

int A[100];
g = h + A[3];

• Using Load Word (lw) in RISC-V:

lw x10,12(x13) # Reg x10 gets A[3]


add x11,x12,x10 # g = h + A[3]

Assume: x13 – base register (pointer to A[0])

Note: 12 – offset in bytes

Offset must be a constant known at assembly time


30
Transfer from Register to Memory

Computer Science 61C Spring 2019 Weaver

• C code

int A[100];
A[10] = h + A[3];

• Using Store Word (sw) in RISC-V:

lw x10,12(x13) # Temp reg x10 gets A[3]


add x10,x12,x10 # Temp reg x10 gets h + A[3]
sw x10,40(x13) # A[10] = h + A[3]

Assume: x13 – base register (pointer)

Note: 12,40 – offsets in bytes

x13+12 and x13+40 must be multiples of 4


31
Loading and Storing Bytes

Computer Science 61C Spring 2019 Weaver

• In addition to word data transfers 



(lw, sw), RISC-V has byte data transfers:
n s ig n ed
has “ u
• load byte: lb S C- V a l s o
w h i c h zero
R I ( lbu)
o a d s Why
• store byte: sb byte” l ll reg i s te r.
te n d t o f i
b y t e sbu?
• Same format as lw, sw ex e d s tore
i g n
• E.g., lb x10,3(x11) no uns
• contents of memory location with address = sum of “3” + contents of
register x11 is copied to the low byte position of register x10.
x10: xxxx xxxx xxxx xxxx xxxx xxxx xzzzbyte
 zzzz
…is copied to “sign-extend”
loaded
This bit
32
Your turn - clickers

Computer Science 61C Spring 2019 Weaver

addi x11,x0,0x3f5 Answer x12


sw x11,0(x5) A 0x5
lb x12,1(x5)
B 0xf
C 0x3
What’s the value in x12? D 0xffffffff

33
Your turn - clickers

Computer Science 61C Spring 2019 Weaver

addi x11,x0,0x3f5 Answer x12


sw x11,0(x5) A 0x5
lb x12,1(x5)
B 0xf
C 0x3
What’s the value in x12? D 0xffffffff

34
Your turn - clickers

Computer Science 61C Spring 2019 Weaver

addi x11,x0,0x8f5 Answer x12


sw x11,0(x5) A 0x8
lb x12,1(x5)
B 0xf8
C 0x3
What’s the value in x12? D 0xfffffff8

35
Your turn - clickers

Computer Science 61C Spring 2019 Weaver

addi x11,x0,0x8f5 Answer x12


sw x11,0(x5) A 0x8
lb x12,1(x5)
B 0xf8
C 0x3
What’s the value in x12?
D 0xfffffff8

36
Administrivia

Computer Science 61C Spring 2019 Weaver

• Load Balancing for labs:

• When the new lab starts, all those in the room from the previous lab have to
leave

• Can then come back if there is more space left

• Tutoring (and lots of it!)

• Can sign up for CS 370 tutoring now

• Link on Piazza

• CSM tutoring starts next week

• As soon as you think you are starting to struggle, get help!

37
RISC-V Logical Instructions

Computer Science 61C Spring 2019 Weaver

Useful to operate on fields of bits within a word

e.g., characters within a word (8 bits)

Operations to pack /unpack bits into words

Called logical operations

C
Java
Logical operations operators operators RISC-V instructions
Bit-by-bit AND & & and
Bit-by-bit OR | | or
Bit-by-bit XOR ^ ^ xor
Shift left logical << << sll
Shift right >> >> srl/sra
38
Logical Shifting

Computer Science 61C Spring 2019 Weaver

• Shift Left Logical: slli x11,x12,2 # x11 = x12<<2

• Store in x11 the value from x12 shifted 2 bits to the left (they fall
off end), inserting 0’s on right; << in C

Before: 0000 0002hex



0000 0000 0000 0000 0000 0000 0000 0010two

After: 0000 0008hex



0000 0000 0000 0000 0000 0000 0000 1000two

What arithmetic effect does shift left have?

• Shift Right Logical: srli is opposite shift; >>

• Zero bits inserted at left of word, right bits shifted off end


39
Arithmetic Shifting

Computer Science 61C Spring 2019 Weaver

• Shift right arithmetic (srai) moves n bits to the right (insert


high-order sign bit into empty bits)
• For example, if register x10 contained

1111 1111 1111 1111 1111 1111 1110 0111two= -25ten

• If execute sra x10, x10, 4, result is:

1111 1111 1111 1111 1111 1111 1111 1110two= -2ten

• Unfortunately, this is NOT same as dividing by 2n

− Fails for odd negative numbers

− C arithmetic semantics is that division should round towards 0


40
Computer Decision Making

Computer Science 61C Spring 2019 Weaver

• Based on computation, do something different

• Normal operation on CPU is to execute instructions in sequence

• Need special instructions for programming languages: if-statement

• RISC-V: if-statement instruction is

beq register1,register2,L1

means: go to instruction labeled L1 



if (value in register1) == (value in register2)

….otherwise, go to next instruction

• beq stands for branch if equal


• Other instruction: bne for branch if not equal
41
Types of Branches

Computer Science 61C Spring 2019 Weaver

• Branch – change of control flow

• Conditional Branch – change control flow depending on


outcome of comparison
• branch if equal (beq) or branch if not equal (bne)

• Also branch if less than (blt) and branch if greater than or equal (bge)

• Unconditional Branch – always branch


• a RISC-V instruction for this: jump (j)
• We will see later than j doesn't exist (its a "pseudo-instruction")

42
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

43
Example if Statement

Computer Science 61C Spring 2019 Weaver

• Assuming assignments below, compile if block

f → x10 g → x11 h → x12

i → x13 j → x14

if (i == j) bne x13,x14,done
f = g + h; add x10,x11,x12
done:

44
Example if-else Statement

Computer Science 61C Spring 2019 Weaver

• Assuming assignments below, compile

f → x10 g → x11 h → x12 i → x13 j → x14

if (i == j) bne x13,x14,else
f = g + h; add x10,x11,x12
else j done
f = g – h; else: sub x10,x11,x12
done:

45
Magnitude Compares in RISC-V

Computer Science 61C Spring 2019 Weaver

• Until now, we’ve only tested equalities (== and != in C); 



General programs need to test < and > as well.

• RISC-V magnitude-compare branches:

“Branch on Less Than”

Syntax: blt reg1,reg2, label


Meaning: if (reg1 < reg2) // Registers are signed

goto label;

• “Branch on Less Than Unsigned”

Syntax: bltu reg1,reg2, label


Meaning: if (reg1 < reg2) // treat registers as unsigned integers
goto label;
“Branch on Greater Than or Equal” (and it’s unsigned version) also exists. 46
But RISC philosophy...

Computer Science 61C Spring 2019 Weaver

• A CISC might also have "branch if greater than"...

• But RISC-V doesn't.

• Instead you can switch the argument

• branch if greater then reg1 reg2...

• branch if less than reg2 reg1

47
C Loop Mapped to RISC-V Assembly
Computer Science 61C Spring 2019 Weaver

int A[20]; # Assume x8 holds pointer to A


int sum = 0; # Assign x10=sum, x11=i
for (int i=0; i<20; i++) add x10, x0, x0 # sum=0
add x11, x0, x0 # i=0
sum += A[i];
addi x12,x0,20 # x12=20
Loop:

bge x11, x12, exit:
sll x13, x11, 2 # i * 4
add x13, x13, x8 # & of A + i
lw x13, 0(x13) # *(A + i)
add x10, x10, x13 # increment sum
addi x11, x11, 1 # i++
j Loop # Iterate
exit:
48
Comments...

Computer Science 61C Spring 2019 Weaver

• The simple translation is


suboptimal!
# Assume x8 holds pointer to A
• A more efficient way:
# Assign x10=sum
• Inner loop is now 4 instructions add x10, x0, x0 # sum=0
rather than 7
add x11, x8, x8 # Copy of A
• And only 1 branch/jump rather than addi x12,x11, 80 # x12=80 + A
two:

Because first time through is always Loop:
true so can move check to the end!
lw x13, 0(x11)
• The compiler will often do this add x10, x10, x13
automatically for optimization
addi x11, x11, 4
• See that i is only used as an index in a blt x11, x12, loop:
loop
49
And Premature Optimization...

Computer Science 61C Spring 2019 Weaver

• In general we want correct translations of C to RISC-V

• It is not necessary to optimize

• Just translate each C statement on its own

• Why?

• Correctness first, performance second

• Getting the wrong answer fast is not what we want from you...

• We're going to need to read your assembly to grade it!

• Multiple ways to optimize, but the straightforward translation is mostly unique-ish.

50
Outline

Computer Science 61C Spring 2019 Weaver

• Assembly Language

• RISC-V Architecture

• Registers vs. Variables

• RISC-V Instructions

• C-to-RISC-V Patterns

• And in Conclusion …

51
In Conclusion,…

Computer Science 61C Spring 2019 Weaver

• Instruction set architecture (ISA) specifies the set of


commands (instructions) a computer can execute

• Hardware registers provide a few very fast variables for


instructions to operate on

• RISC-V ISA requires software to break complex operations


into a string of simple instructions, but enables faster, simple
hardware

• Assembly code is human-readable version of computer’s


native machine code, converted to binary by an assembler

52

You might also like