Published by : International Journal of Engineering Research & Technology (IJERT)

http://www.ijert.org ISSN: 2278-0181

Vol. 6 Issue 04, April-2017

Design of a 16-bit RISC Processor Using VHDL

Karansingh P. Thakor, Ankushkumar Pal Prof. Madhura Shirodkar

Department of EXTC Department of EXTC
Xavier Institute of Engineering Xavier Institute of Engineering
Mumbai, India Mumbai, India

Abstract— This paper targets the design and implementation specified in a register (Rt). There is an unconditional jump that
of a 16-bit RISC Processor using VHDL (Very High Speed jumps to a memory address that is calculated by adding the
Integrated Circuit Hardware Description Language). As IC chip current value in the Program Counter and the 8-bit offset
design involves complex computations and intense usage of specified in the instruction. This gives the target branch
resources, by using an HDL we can save resources and time by
address. A similar procedure is followed by the Conditional
implementing it using the software approach. The
implementation strategies have been borrowed from the popular Jumps but the address is calculated beforehand as an optimistic
MIPS architecture to a certain extent. The processor has 16-bit operation and is stored in a special register, so that if the
arithmetic and logical instruction set which has been designed condition is true then the branch target address is written into
and simulated. The instruction set is extremely simple and it gives the Program Counter. If the condition is false then the Program
an insight into the kind of hardware that would be required to Counter will not be modified and execution will continue as if
execute the instructions accordingly. The ALU, instruction no branching took place. There is also a no operation (NOP)
register, program counter, register file, control unit and memory instruction. The complete instruction set is given in Table I.
have been integrated in the proposed processor. All the modules
in the design are coded in VHDL to ease the description, TABLE I. INSTRUCTION SET
verification, simulation and hardware implementation. The
blocks are designed using the behavioral approach. Instruction Opcode Operation
1 ADD 0 0 0 0 Rd = Rs1 + Rs2
Keywords — RISC Processor, MIPS, SPU, ALU, ISA, VHDL, 0 0 0 1 If RS1 > RS2
PC, Opcode, clock, timing, FPGA, instruction, LOAD, JZ, JNZ, 2 SUB Then Rd = RS1 – RS2
ADD, ALB, AGB, waveform, RTL Schematic, 16-bit, Xilinx ISE, Else Rd = RS2 – RS1
3 AND 0 0 1 0 Rd = Rs1 & Rs2
Isim.
4 OR 0 0 1 1 Rd = Rs1 | Rs2
I. INTRODUCTION
5 NOT 0 1 0 0 Rd = ~ Rs
Processors are divided into 3 categories 8-bits, 16-bits
and 32-bits depending upon the demand of performance, cost, 6 XOR 0 1 0 1 Rd = Rs1 ^ Rs2
power and programmability. 16-bit processors have higher If Rs1 = Rs2
performance and power than 8-bit processors and lower power Then Equal = 1, else Equal =0
consumption than 32-bit processors. They are often used in 16- If R1 = 0
bit applications such as disk driver controller, cellular Then AZ = 1, else AZ=0
communication and airbags. A RISC processor uses load-store CMP If Rs2 =0
architecture, fixed length instructions and pipelining. In load- 7 0 1 1 0
(Equal Then BZ =1, else BZ =0
store architecture, load instruction reads data from memory If Rs1> Rs2
and writes it to a register, data-processing instructions process Then AGB = 1, else AGB = 0
data available in registers and write the result to a register and
If Rs1< Rs2
store instruction copies data from register to memory. Then ALB = 1, else ALB = 0
8 SHIFT LEFT 0 1 1 1 Rd=Rs1 <<1
This paper investigates the methodology of soft-core
SHIFT 1 0 0 0
processor development. The software used was Xilinx ISE 9
RIGHT
Rd=Rs1 >>1
14.5. The target family chosen was Spartan 6 FPGA with 1 0 0 1
10 LOAD Rd = Mem[Rs1]
device XC6SLX9 and package CSG324. The simulation was
1 0 1 0
performed in ISim. 11 STORE Mem[Rs1] = Rs2

12 JUMP 1 0 1 1 PC = PC+Offset
II. INSTRUCTION SET
13 NOP 1 1 0 0 No operation
The first step was to design the Instruction Set Architecture
(ISA). The instruction set contains instructions supported by 14 JZ 1 1 0 1 PC = PC+Offset if Rd == 0
the processor. The first nine instructions perform arithmetic 1 1 1 0
15 JNZ PC = PC+Offset if Rd != 1
and logical instructions. The memory read instruction reads the
LOAD 8-BIT 1 1 1 1
data from the memory address which is specified in a register 16
IMMEDIATE
Rd = 8-bit Immediate
(Rs) and writes the data word to the register mentioned in the
instruction (Rd). The memory write instruction writes the data
in the specified register (Rs) to the target address which is also

IJERTV6IS040284 www.ijert.org 238

(This work is licensed under a Creative Commons Attribution 4.0 International License.)
Published by : International Journal of Engineering Research & Technology (IJERT)
http://www.ijert.org ISSN: 2278-0181
Vol. 6 Issue 04, April-2017

III. INSTRUCTION FORMAT C. Memory Access Instrucions

After deciding the instructions, the next step was to There are two memory access instructions, a memory read
decide the instruction format. The uniform and orderly and a memory write. The memory read instruction (or LOAD
placement of the fields in the instruction is called instruction instruction) loads a 16-bit word into the register address
format. The instruction words are of 16-bits each. For specified in Rd. The memory address is stored in the first
uniformity, the operation code (opcode) was kept as 4-bits for source register (Rs1). The memory write (or STORE)
all the instructions. So there are 16 instructions. The register instruction takes the contents in the specified source register
file has 16 registers of 16-bits each. In order to address 16 (Rs2) and writes it to a memory location stored in the first
registers, we need a 4-bit register address field in an source register (Rs1).
instruction.
Opcode Destination Register Source Register 1 Unused
(4-bits) Address (4-bits) (Rd) Address (4-bits) (Rs1) (4-bits)
A. Arithmetic and Logical Instructions
The arithmetic and logical instructions have a common Fig. 4. Format of Memory Read (LOAD) instruction
format : the opcode, the destination register address (Rd), the
first source register address (Rs1) and the second source Opcode Unused Source Register 1 Source Register 2
(4-bits) (4-bits) Address (4-bits) (Rs1) Address (4-bits) (Rs2)
address (Rs2). This format applies to two operand instructions
like AND, SUB etc. For single operand instructions like NOT Fig. 5. Format of Memory Write (STORE) instruction
only a single source register address is required. Hence the 4-
bits for source register 1 are unused and we use the address in D. Unconditional Jump
the field for the second register. The unconditional jump will change the branch of
Opcode Destination Source Register 1 Source Register 2 execution of the program and will load the previously
(4-bits) Register (Rd) Address (4-bits) Address (4-bits) calculated target address into the Program Counter. The 8-bit
Address (4-bits) (Rs1) (Rs2) offset is provided in the first 8-bits of the instruction. The next
Fig. 1. Format of an Arithmetic or Logical Instruction four bits are unused.
B. Compare Instruction Opcode(4-bits) Unused (4-bits) 8-bit offset (Immediate)
The compare instruction compares the two source
Fig. 6. Format Unconditional (JMP) instruction
addresses (Rs1 and Rs2) and outputs a word that is stored in
the destination register (Rd). Each bit represents some E. Conditional Jumps – JZ and JNZ
characteristic of the data. There are five conditions and each of
the first five bits of the output word correspond to a single As stated before, the compare instruction also sets the flags
condition. If any bit is set it means that, that condition is true. of the processor. These flags are used to decide whether the
The interpretation of each bit is given in Table II. The condition to be checked for each of these jumps is true or not.
instruction also sets the five flag bits of the processor. These
flag bits are used for the conditional jump instructions to Opcode Address of Register to be checked 8-bit offset (Immediate)
decide if that condition is true. (4-bits) (4-bits)
Fig. 7. Format Conditional (JZ & JNZ) instruction
Opcode Destination Source Register 1 Source Register 2
(4-bits) Register Address (4-bits) Address (4-bits)
Address (4-bits) (Rs1) (Rs2)  JZ – Jump if Zero
(Rd) This instruction checks whether the register specified the
Fig. 2. Format of Compare Instruction 4-bits after the opcode has a zero value or not. If it is, then
the condition is true and the branch target address will be
written into the program counter. If false the program
counter remains unaffected.

Fig. 3. Format of Compare Instruction Output word  JNZ – Jump if Non-Zero

JNZ has exactly the opposite condition as JZ, it checks if
TABLE II. INTERPRETATION OF COMPARE OUTPUT WORD the register specified is not zero. But the instruction
Bit Abbreviation Meaning
0 EQUAL 0 Rs1 and Rs2 are equal format is the same.
1 Rs1 and Rs2 are unequal
1 AZ 0 Rs1 is NON-ZERO
F. Load 8-Bit Immediate
1 Rs1 is ZERO This instruction is useful to load 8-bit immediate data into
2 BZ 0 Rs2 is NON-ZERO the registers. For now, the processor treats the 8-bit immediate
1 Rs2 is ZERO as an unsigned integer and only appends 8 zeroes (i.e. 0x00)
3 AGB 0 Rs1 is not greater than Rs2 ahead of the number to make it 16-bit. This is only for the
1 Rs1 is greater than Rs2
preliminary stage. A sign-extension unit would be much more
4 ALB 0 Rs2 is not greater than Rs1
1 Rs2 is greater than Rs1 efficient for this purpose. The format is given in Figure 8.

IJERTV6IS040284 www.ijert.org 239

(This work is licensed under a Creative Commons Attribution 4.0 International License.)
Published by : International Journal of Engineering Research & Technology (IJERT)
http://www.ijert.org ISSN: 2278-0181
Vol. 6 Issue 04, April-2017

Opcode Destination Register 8-bit offset (Immediate) There are certain drawbacks of this version of the
(4-bits) Address (4-bits) (Rd) processor. Instructions have to be fed directly to the IR, latency
periods need to be inserted between instructions and it cannot
Fig. 8. Format of LI instruction
interface to memory or perform branching.
IV. ARCHITECTURE
After the instructions and their formats were finalized, the B. SPU Version 2
architecture could finally be developed. The architecture was This version is self-sustaining and can fetch instructions on
developed in stages. The processor was initially simple in its own. The SRAM module acts as memory. No latency
design in stage 1, so it was called simple processing unit or periods are needed. Inspiration was taken from the multi-cycle
SPU for short. But in the further stages, more of the MIPS datapath for this implementation. New components were
instructions, were implemented and in stage 3 all the added to facilitate this such as the Control Unit (CU), Program
instructions were implemented. The stages are described Counter (PC) and some multiplexers. The processor uses
below. several components in a single cycle and the processor uses a
5-state finite state machine to control these components. In
A. SPU Version 1 each state the CU generates the control signals for each module
in the different states. The five states are: START, FETCH,
It is a simple processor. It is simply a test module which DECODE, EXECUTE & WRITEBACK.
cannot be used as a part of any system. There was not much
functionality built into this processor. Only 3 blocks were
implemented:

Fig. 10. SPU Version 2 architecture

Fig. 9. SPU Version 1 architecture There were no proper means to write instructions to
memory as no user interface was created and there was no
 Instruction Register (IR) means for branching, but it successfully performed arithmetic
The ISA is uniform as bit ranges of instructions are shared. and logical instructions at a good speed. A VHDL testbench
The decoder takes the bit fields, separates them was created for this processor. A small example program could
accordingly and feeds them to the other units it is be typed into the SRAM module and for simulation of the
connected to. testbench.

 ALU The state diagram is shown below in Figure 11. It only

Works like a standard ALU in this version describes the execution of arithmetic and logical instructions.

 General Purpose Register File (GPRF)

On each clock cycle, it updates the source 1 and 2 register
outputs when given the selection inputs for them and write
to the destination register if enabled.

IJERTV6IS040284 www.ijert.org 240

(This work is licensed under a Creative Commons Attribution 4.0 International License.)
Published by : International Journal of Engineering Research & Technology (IJERT)
http://www.ijert.org ISSN: 2278-0181
Vol. 6 Issue 04, April-2017

Fig. 11. SPU Version 2 state diagram

Fig. 13. SPU Version 3 state digram
C. SPU Version 3
Version 3 implements all 16 instructions. The architecture TABLE III. CONTROL SIGNALS USED BY THE
was modified. The Control Unit was modified the most as it PROCESSOR
Control Signal Value Function
had to provide more control signals than before. Only registers
0 Disables write to register file
and multiplexers were added as these are low on real-estate and GPRF_wr 1 Enables write to register file
are also cheaper to implement as compared to completely new 0 Disables write to instruction decoder
modules. The extra control signals that were added were for IR_wr 1 Enables write to instruction decoder
the branching and memory write instructions. The control 0 Disables write to Program Counter
PC_Write 1 Enables write to Program Counter
signals are given in the Table III. The Figure 12 shows the
0 Disables write to Program Counter for
architecture of the processor. PC_WCond conditional jumps
1 Enables write to Program Counter for
conditional jumps
0 Passes the calculated next address to the
Program Counter
PC_Source Passes the branch target address to the
Program Counter for an unconditional
1 jump or if the condition is true for a
conditional jump
0000- Takes value passed from Control Unit to
ALU_op 1111 decide what action takes place
0 Passes data in source register 1 to ALU
ALU_Src_1 1 Passes PC_addr to ALU during FETCH
cycle
00 Passes data in source register 2 to ALU
ALU_Src_2 01 Passes X’0001’ to ALU
10 Passes 8-bit Immediate to ALU
0 Passes the address of source register 2
when the instruction is not a conditional
Rs2_select jump
1 Passes the address of the register to be
checked for a conditional jump
0 Passes the data calculated by ALU to
register file
Fig. 12. SPU Version 3 architecture MemtoReg Passes the data stored in a memory
1 location during a memory read
The processor is enclosed in the black box. The memory instruction
is only an external unit. This version can interface with the 0 Passes the Program Counter contents as
memory using control signals Mem_write, Mem_read and the the next address
IorD Passes the memory address stored in
respective lines for sending and receiving address and data 1 source register 1 for a memory write
from memory. Some new states were also added to handle the instruction
memory read, write, conditional and unconditional branching Mem_Write 0 Disables write to Memory
instructions. 1 Enables write to Memory
Mem_Read 0 Disables read from Memory
1 Enables read from Memory
Cu_state 0000- Tells us what state the processor is in
1111

IJERTV6IS040284 www.ijert.org 241

(This work is licensed under a Creative Commons Attribution 4.0 International License.)
Published by : International Journal of Engineering Research & Technology (IJERT)
http://www.ijert.org ISSN: 2278-0181
Vol. 6 Issue 04, April-2017

V. SIMULATION RESULTS B. Device Utilization

A. Top-Level Module TABLE IV. RESOURCES UTILIZED BY PROCESSOR
A top-level module that contains the instances of the Slice Logic Utilization Utilization
processor, an external memory and an address decoder was Number of Slice Registers 150 of 11,400 1%
created. Number of Slice LUTs 201 of 5,720 3%
Number of IOBs 62 of 200 1%
Number of occupied Slices 69 of 1,430 4%
The module SPU_3_top is the processor block. All the
components of the processor are instantiated in this top-level C. Simulation in ISim
block. The RTL schematic is shown in Figure 14. The example program given in Table V contains a single
instruction of each type. A clock of 2us was used.
As very large memories take a long time to synthesize and
utilize too much of the FPGAs resources a small memory with
 LOAD 8-BIT IMMEDIATE
16 addresses was chosen for simulation purposes, so an
The LI instruction takes 4 cycles to execute. The
address decoder was used that could convert a 16-bit address
instruction here is xF001. It loads Immediate x0001 into
to a 4-bit address. The memory module contains the test
register R0. Waveform is shown in Figure 16. Here it takes
program to be executed. The program is typed into the memory
8us to execute.
before simulation.
 ADD
The ADD instruction takes 4 cycles to execute. The
instruction here is x0301. It adds the value in registers R0
and R1 and places the answer in R3. Waveform is shown
in Figure 17. All 9 arithmetic and logical instructions in
the instruction set take the same amount of time for
execution.
TABLE V. EXAMPLE PROGRAM IN MEMORY

Address Instruction Machine Code

(0000)16 LI R0 x01 (𝐹001)16
(0001)16 LI R1 x02 (𝐹102)16
(0002)16 LI R2 x0A (𝐹20𝐴)16
(0003)16 ADD R3, R0, R1 (0301)16
(0004)16 LI R5 x0D (𝐹50𝐷)16
(0005)16 JZ R4 x03 (𝐷403)16
(0006)16 0000 (0000)16
Fig. 14. RTL Schematic of SPU_3_top processor (0007)16 0000 (0000)16
(0008)16 ADD R4, R0, R2 (0402)16
The RTL schematic is expanded below and it shows us the (0009)16 STORE R5, R4 (𝐴054)26
different blocks in the processor. (000𝐴)16 JMP x005 (𝐵005)16
(000𝐵)16 0000 (0000)16
(000𝐶)16 0000 (0000)16
(000𝐷)16 0000 (0000)16
(000𝐸)16 0000 (0000)16
(000𝐹)16 LOAD R8, R2 (9820)16

Fig. 16. Waveform of LI instruction

Fig. 15. Expanded RTL Schematic of SPU_3_top

IJERTV6IS040284 www.ijert.org 242

(This work is licensed under a Creative Commons Attribution 4.0 International License.)
Published by : International Journal of Engineering Research & Technology (IJERT)
http://www.ijert.org ISSN: 2278-0181
Vol. 6 Issue 04, April-2017

Fig. 17. Waveform of ADD instruction

Fig. 20. Waveform of JMP instruction
 JZ – Conditional Jump
The JZ instruction takes 5 cycles to execute, irrespective if  LOAD – Memory Read
condition is true or false. The instruction here is xD403. It The LOAD instruction will write the data stored in the memory
checks the value in register 4 and if the condition is true it address which is stored in the source register 1 to the
updates the program counter with the new address which destination register. It takes 4 cycles to execute. Here the
offsets the current address by 3. As the current address is instruction is x9820. It loads register 8 wth the data at address
x0005 and the condition is true, the next address will be x0008. stored in register 2. The waveform is shown in Figure 21.
The JNZ instruction executes in the same manner. Waveform
is shown in Figure 18.

Fig. 21. Waveform of JMP instruction

VI. CONCLUSION
Fig. 18. Waveform of JZ instruction
A 16-bit RISC processor has been realized. It can execute
an instruction set with 16 instructions of different classes like
 STORE – Memory Write
arithmetic and logical, jumping - both conditional and
The STORE instruction writes the data in a register to a
unconditional jumps and memory interface instructions. The
given memory location. It takes 5 cycles to execute. Here the
simulation output is compared with the expected results and
instruction is xA054. It writes the data stored in register 4 to
the functionality is found correct.
the memory address stored in register 5. The processor goes
through the MEM_ADDRESS and MEM_ACCESS states
The design can be improved in several ways to make it
before finally performing the write. Waveform is shown in
more sophisticated. A user interface can be developed so that
Figure 19.
a user can enter programs and write them to memory which
will then be fetched for execution.

ACKNOWLEDGMENTS
The authors would like to thank their project guide, Prof.
Madhura Shirodkar. Her insight and vision have made it
possible for us to pursue and understand developments in the
areas of Processor Design, VHDL programming and FPGAs.

The authors would also like to thank our Principal,

Director, teachers and staff of the Xavier Institute of
Fig. 19. Waveform of STORE instruction Engineering, Mumbai, India for providing all the facilities to
conduct this project.
 JMP – Unconditional Jump
The instruction will cause a jump to the next address formed
by adding the current address in the program counter to the 8-
bit offfset in the instruction. It takes 3 cycles to execute. Here
the instruction is xB005. The current address is x000A after
adding the offset we get the new address as x000F. The
execution will now jump to that memory location. The
instruction at that address is x9820. Waveform is shown in
Figure 20.

IJERTV6IS040284 www.ijert.org 243

(This work is licensed under a Creative Commons Attribution 4.0 International License.)
Published by : International Journal of Engineering Research & Technology (IJERT)
http://www.ijert.org ISSN: 2278-0181
Vol. 6 Issue 04, April-2017

REFERENCES
[1] Vishwas V. Balpande, Abhishek B. Pande, Meeta J. Walke,
Bhavna D. Choudhari, Kiran R. Bagade, “Design and
Implementation of 16 Bit Processor on FPGA”, IJARCSSE,
January 2015.
[2] Nupur Gupta, Pragati Gupta, Himanshi Bajpai, Richa Singh,
Shilpa Saxena “Analysis of 16 Bit Microprocessor Architecture
on FPGA Using VHDL”, IJAREEIE, April 2014.
[3] V. R. Gaikwad, “Design, Implementation and Testing of 16 bit
RISC Processor”, IOSR-JVSP, March 2013.
[4] Amanjyot Singh Johar, “16 bit Reduced Instruction Set
Computer (RISC) Processor Design A Project Report” ,
Department of Electrical and Computer Engineering, University
of Illinois at Chicago, September 2013.
[5] M.Kishore Kumar, MD.Shabeena Begum, “FPGA Based
Implementation of a 32-bit RISC processor”, IJERA, Setember
2011.
[6] David A. Patterson, David R. Ditzel, “The Case for The
Reduced Instruction Set Computer”.
[7] J.B. Nade, Dr. R. V. Sarwadnya, “The Soft Core Processors : A
Review”, IJIREEICE, December 2015.
[8] Anders Wallander, “A VHDL Implementation of a MIPS” ,
Department of Computer Science and Engineering, Lulea
Teniska Universitet, January 2000
[9] Anjana R, Krunal Gandhi, “VHDL Implementation of a MIPS
RISC Processor”, IJARCSSE, August 2012.
[10] David A. Patterson, John L. Hennessey, Computer Organisation
And Design, Third edition, 2007.

IJERTV6IS040284 www.ijert.org 244

(This work is licensed under a Creative Commons Attribution 4.0 International License.)