加载存储指令的实现

已于 2022-04-27 19:30:20 修改
阅读量151 收藏
点赞数
分类专栏： OpenMIPS 文章标签： fpga
于 2022-04-25 22:59:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41793792/article/details/124399808
版权

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一个字节为8位，一个半字为16位，一个字为32位
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
修改ID，主要是增加译码和一个输出inst_o
lwl模块中reg2也需要读！
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

`include "defines.v"

module id_ex(

	input wire					  clk,
	input wire					  rst,

	//从译码阶段传递的信息
	input wire[`AluOpBus]       id_aluop,	//[7:0]
	input wire[`AluSelBus]      id_alusel,	//[2:0]
	input wire[`RegBus]         id_reg1,
	input wire[`RegBus]         id_reg2,
	input wire[`RegAddrBus]     id_wd,
	input wire                  id_wreg,	
	input wire[`RegBus]         id_link_address,	//处于译码阶段的转移指令要保存的返回地址
	input wire                  id_is_in_delayslot,	//当前处于译码阶段的指令是否位于延迟槽
	input wire                  next_inst_in_delayslot_i, //下一条进入译码阶段的指令是否位于延迟槽

	//当前处于译码阶段的指令
	input wire[`RegBus]         id_inst,	
	
	//来自控制模块的
	input wire[5:0]				 stall,

	//传递到执行阶段的
	output reg[`AluOpBus]       ex_aluop,
	output reg[`AluSelBus]      ex_alusel,
	output reg[`RegBus]         ex_reg1,
	output reg[`RegBus]         ex_reg2,
	output reg[`RegAddrBus]     ex_wd,
	output reg                  ex_wreg,
	output reg[`RegBus]         ex_link_address,		//处于执行阶段的转移指令要保存的返回地址
	output reg                  ex_is_in_delayslot,	//当前处于执行阶段的指令是否位于延迟槽
	output reg                  is_in_delayslot_o,		//当前译码阶段的指令是否位于延迟槽
	
	//当前处于执行阶段的指令
	output reg[`RegBus]         ex_inst
	
);
	//打一拍传过去
	//1.当stall[2]为stop，stall[3]为nostop，表示译码阶段暂停，执行阶段继续
	//  使用空指令作为下一个周期进入执行阶段的指令
	//2.当stall[2]为nostop，译码阶段继续，译码后的指令进入执行阶段
	//3.其余情况，保持不变
	always @ (posedge clk) begin
		if (rst == `RstEnable) begin
			ex_aluop  <= `EXE_NOP_OP;
			ex_alusel <= `EXE_RES_NOP;
			ex_reg1   <= `ZeroWord;
			ex_reg2   <= `ZeroWord;
			ex_wd     <= `NOPRegAddr;
			ex_wreg   <= `WriteDisable;
			ex_link_address <= `ZeroWord;
			ex_is_in_delayslot <= `NotInDelaySlot;
			is_in_delayslot_o <= `NotInDelaySlot;
			ex_inst <= `ZeroWord;
		end 
		else if(stall[2] == `Stop && stall[3] == `NoStop) begin
			ex_aluop  <= `EXE_NOP_OP;
			ex_alusel <= `EXE_RES_NOP;
			ex_reg1 	 <= `ZeroWord;
			ex_reg2   <= `ZeroWord;
			ex_wd 	 <= `NOPRegAddr;
			ex_wreg 	 <= `WriteDisable;
			ex_link_address <= `ZeroWord;
			ex_is_in_delayslot <= `NotInDelaySlot;	
			ex_inst <= `ZeroWord;		
		end 
		else if(stall[2] == `NoStop) begin		
			ex_aluop  <= id_aluop;
			ex_alusel <= id_alusel;
			ex_reg1 	 <= id_reg1;
			ex_reg2 	 <= id_reg2;
			ex_wd 	 <= id_wd;
			ex_wreg   <= id_wreg;	
			ex_link_address <= id_link_address;
			ex_is_in_delayslot <= id_is_in_delayslot;
			is_in_delayslot_o <= next_inst_in_delayslot_i;	
			ex_inst <= id_inst;
		end
	end
	
endmodule

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

`include "defines.v"

module mem(

	input wire						  rst,
	
	//来自执行阶段的信息	
	input wire[`RegAddrBus]      wd_i,
	input wire                   wreg_i,
	input wire[`RegBus]			  wdata_i,
	input wire[`RegBus]          hi_i,
	input wire[`RegBus]          lo_i,
	input wire                   whilo_i,
	
   //
	input wire[`AluOpBus]        aluop_i,		//访存阶段的指令要进行的运算的子类型
	input wire[`RegBus]          mem_addr_i,	//访存阶段加载、存储指令对应的存储器地址
	input wire[`RegBus]          reg2_i,		//访存阶段的存储指令要存储的数据或lwl/lwr要加载到的目的段寄存器原始值

	//来自memory的信息
	input wire[`RegBus]          mem_data_i,	//从数据存储器读取的数据
	
	//送到回写阶段的信息
	output reg[`RegAddrBus]      wd_o,
	output reg                   wreg_o,
	output reg[`RegBus]			  wdata_o,
	output reg[`RegBus]          hi_o,
	output reg[`RegBus]          lo_o,
	output reg                   whilo_o,
	
	//送到memory的信息
	output reg[`RegBus]          mem_addr_o,	//要访问的数据存储器地址
	output wire						  mem_we_o,		//是否写操作
	output reg[3:0]              mem_sel_o,	//字节选择信号
	output reg[`RegBus]          mem_data_o,	//要写入数据存储器的数据
	output reg                   mem_ce_o		//数据存储器使能信号
);

	wire[`RegBus] zero32;
	reg           mem_we;

	assign mem_we_o = mem_we ;	//外部数据存储器RAM的读、写信号
	assign zero32 = `ZeroWord;
	
	always @ (*) begin
		if(rst == `RstEnable) begin
			wd_o <= `NOPRegAddr;
			wreg_o <= `WriteDisable;
		   wdata_o <= `ZeroWord;
		   hi_o <= `ZeroWord;
		   lo_o <= `ZeroWord;
		   whilo_o <= `WriteDisable;
		   mem_addr_o <= `ZeroWord;
		   mem_we <= `WriteDisable;
		   mem_sel_o <= 4'b0000;
		   mem_data_o <= `ZeroWord;
		   mem_ce_o <= `ChipDisable;				
		end 
		else begin
		   wd_o <= wd_i;
			wreg_o <= wreg_i;
			wdata_o <= wdata_i;
			hi_o <= hi_i;
			lo_o <= lo_i;
			whilo_o <= whilo_i;
			mem_we <= `WriteDisable;
			mem_addr_o <= `ZeroWord;
			mem_sel_o <= 4'b1111;
			mem_ce_o <= `ChipDisable;
			case (aluop_i)
			
				`EXE_LB_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteDisable;	//加载操作
					mem_ce_o <= `ChipEnable;	//要访问数据存储器
					case (mem_addr_i[1:0])		//反正就是根据算出来的地址的后两位来确定字节
						2'b00:	begin
							wdata_o <= {{24{mem_data_i[31]}},mem_data_i[31:24]};
							mem_sel_o <= 4'b1000;
						end
						2'b01:	begin
							wdata_o <= {{24{mem_data_i[23]}},mem_data_i[23:16]};
							mem_sel_o <= 4'b0100;
						end
						2'b10:	begin
							wdata_o <= {{24{mem_data_i[15]}},mem_data_i[15:8]};
							mem_sel_o <= 4'b0010;
						end
						2'b11:	begin
							wdata_o <= {{24{mem_data_i[7]}},mem_data_i[7:0]};
							mem_sel_o <= 4'b0001;
						end
						default:	begin
							wdata_o <= `ZeroWord;
						end
					endcase
				end
				
				`EXE_LBU_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteDisable;
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin
							wdata_o <= {{24{1'b0}},mem_data_i[31:24]};
							mem_sel_o <= 4'b1000;
						end
						2'b01:	begin
							wdata_o <= {{24{1'b0}},mem_data_i[23:16]};
							mem_sel_o <= 4'b0100;
						end
						2'b10:	begin
							wdata_o <= {{24{1'b0}},mem_data_i[15:8]};
							mem_sel_o <= 4'b0010;
						end
						2'b11:	begin
							wdata_o <= {{24{1'b0}},mem_data_i[7:0]};
							mem_sel_o <= 4'b0001;
						end
						default:	begin
							wdata_o <= `ZeroWord;
						end
					endcase				
				end
				
				`EXE_LH_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteDisable;
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin
							wdata_o <= {{16{mem_data_i[31]}},mem_data_i[31:16]};
							mem_sel_o <= 4'b1100;
						end
						2'b10:	begin
							wdata_o <= {{16{mem_data_i[15]}},mem_data_i[15:0]};
							mem_sel_o <= 4'b0011;
						end
						default:	begin
							wdata_o <= `ZeroWord;
						end
					endcase					
				end
				
				`EXE_LHU_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteDisable;
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin
							wdata_o <= {{16{1'b0}},mem_data_i[31:16]};
							mem_sel_o <= 4'b1100;
						end
						2'b10:	begin
							wdata_o <= {{16{1'b0}},mem_data_i[15:0]};
							mem_sel_o <= 4'b0011;
						end
						default:	begin
							wdata_o <= `ZeroWord;
						end
					endcase				
				end
				
				`EXE_LW_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteDisable;
					wdata_o <= mem_data_i;
					mem_sel_o <= 4'b1111;
					mem_ce_o <= `ChipEnable;		
				end
				
				`EXE_LWL_OP:		begin
					mem_addr_o <= {mem_addr_i[31:2], 2'b00};	//lwl地址后两位置0
					mem_we <= `WriteDisable;
					mem_sel_o <= 4'b1111;							//lwl读一个字，所以全1
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])							//根据后两位与原始值组合 就是只保存高位
						2'b00:	begin
							wdata_o <= mem_data_i[31:0];
						end
						2'b01:	begin
							wdata_o <= {mem_data_i[23:0],reg2_i[7:0]};
						end
						2'b10:	begin
							wdata_o <= {mem_data_i[15:0],reg2_i[15:0]};
						end
						2'b11:	begin
							wdata_o <= {mem_data_i[7:0],reg2_i[23:0]};	
						end
						default:	begin
							wdata_o <= `ZeroWord;
						end
					endcase				
				end
				
				`EXE_LWR_OP:		begin
					mem_addr_o <= {mem_addr_i[31:2], 2'b00};
					mem_we <= `WriteDisable;
					mem_sel_o <= 4'b1111;
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin
							wdata_o <= {reg2_i[31:8],mem_data_i[31:24]};
						end
						2'b01:	begin
							wdata_o <= {reg2_i[31:16],mem_data_i[31:16]};
						end
						2'b10:	begin
							wdata_o <= {reg2_i[31:24],mem_data_i[31:8]};
						end
						2'b11:	begin
							wdata_o <= mem_data_i;	
						end
						default:	begin
							wdata_o <= `ZeroWord;
						end
					endcase					
				end
				
				`EXE_SB_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteEnable;		//存储操作
					mem_data_o <= {reg2_i[7:0],reg2_i[7:0],reg2_i[7:0],reg2_i[7:0]};	//最低字节
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin
							mem_sel_o <= 4'b1000;
						end
						2'b01:	begin
							mem_sel_o <= 4'b0100;
						end
						2'b10:	begin
							mem_sel_o <= 4'b0010;
						end
						2'b11:	begin
							mem_sel_o <= 4'b0001;	
						end
						default:	begin
							mem_sel_o <= 4'b0000;
						end
					endcase				
				end
				
				`EXE_SH_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteEnable;
					mem_data_o <= {reg2_i[15:0],reg2_i[15:0]};
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin
							mem_sel_o <= 4'b1100;
						end
						2'b10:	begin
							mem_sel_o <= 4'b0011;
						end
						default:	begin
							mem_sel_o <= 4'b0000;
						end
					endcase						
				end
				
				`EXE_SW_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteEnable;
					mem_data_o <= reg2_i;
					mem_sel_o <= 4'b1111;	
					mem_ce_o <= `ChipEnable;		
				end
				
				`EXE_SWL_OP:		begin
					mem_addr_o <= {mem_addr_i[31:2], 2'b00};	//置0 因为swl最多可能向RAM写入一个字
					mem_we <= `WriteEnable;
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])							//zero32拿来补0的
						2'b00:	begin						  
							mem_sel_o <= 4'b1111;
							mem_data_o <= reg2_i;
						end
						2'b01:	begin
							mem_sel_o <= 4'b0111;
							mem_data_o <= {zero32[7:0],reg2_i[31:8]};
						end
						2'b10:	begin
							mem_sel_o <= 4'b0011;
							mem_data_o <= {zero32[15:0],reg2_i[31:16]};
						end
						2'b11:	begin
							mem_sel_o <= 4'b0001;	
							mem_data_o <= {zero32[23:0],reg2_i[31:24]};
						end
						default:	begin
							mem_sel_o <= 4'b0000;
						end
					endcase							
				end
				
				`EXE_SWR_OP:		begin
					mem_addr_o <= {mem_addr_i[31:2], 2'b00};
					mem_we <= `WriteEnable;
					mem_ce_o <= `ChipEnable;
					case (mem_addr_i[1:0])
						2'b00:	begin						  
							mem_sel_o <= 4'b1000;
							mem_data_o <= {reg2_i[7:0],zero32[23:0]};
						end
						2'b01:	begin
							mem_sel_o <= 4'b1100;
							mem_data_o <= {reg2_i[15:0],zero32[15:0]};
						end
						2'b10:	begin
							mem_sel_o <= 4'b1110;
							mem_data_o <= {reg2_i[23:0],zero32[7:0]};
						end
						2'b11:	begin
							mem_sel_o <= 4'b1111;	
							mem_data_o <= reg2_i[31:0];
						end
						default:	begin
							mem_sel_o <= 4'b0000;
						end
					endcase											
				end 
				default:		begin
				end
			endcase				
		end  
	end      
			
endmodule

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

`include "defines.v"

module data_ram(

	input	wire								clk,
	input wire								ce,
	input wire								we,
	input wire[`DataAddrBus]			addr,
	input wire[3:0]						sel,
	input wire[`DataBus]					data_i,	//要写入的数据
	output reg[`DataBus]					data_o
	
);
	//定义四个字节数组  
	//ByteWidth 7:0 字节宽度
	//DataMemNum 131071 RAM大小 单位是字 此处是128K word
	reg[`ByteWidth]  data_mem0[0:`DataMemNum-1];
	reg[`ByteWidth]  data_mem1[0:`DataMemNum-1];
	reg[`ByteWidth]  data_mem2[0:`DataMemNum-1];
	reg[`ByteWidth]  data_mem3[0:`DataMemNum-1];

	//写操作
	//DataMemNumLog2 17 实际使用的地址宽度
	always @ (posedge clk) begin
		if (ce == `ChipDisable) begin
			//data_o <= ZeroWord;
		end 
		else if(we == `WriteEnable) begin
			if (sel[3] == 1'b1) begin
		      data_mem3[addr[`DataMemNumLog2+1:2]] <= data_i[31:24];
		   end
			if (sel[2] == 1'b1) begin
		      data_mem2[addr[`DataMemNumLog2+1:2]] <= data_i[23:16];
		   end
		   if (sel[1] == 1'b1) begin
		      data_mem1[addr[`DataMemNumLog2+1:2]] <= data_i[15:8];
		   end
			if (sel[0] == 1'b1) begin
		      data_mem0[addr[`DataMemNumLog2+1:2]] <= data_i[7:0];
		   end			   	    
		end
	end
	
	//读操作
	always @ (*) begin
		if (ce == `ChipDisable) begin
			data_o <= `ZeroWord;
	   end 
		else if(we == `WriteDisable) begin	//地址仍左移了两位 因为按字节寻址 所以乘4
		   data_o <= {data_mem3[addr[`DataMemNumLog2+1:2]],
		              data_mem2[addr[`DataMemNumLog2+1:2]],
		              data_mem1[addr[`DataMemNumLog2+1:2]],
		              data_mem0[addr[`DataMemNumLog2+1:2]]};
		end 
		else begin
			data_o <= `ZeroWord;
		end
	end		

endmodule

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

`include "defines.v"

module LLbit_reg(

	input	wire							clk,
	input wire							rst,
	
	input wire                    flush,	//是否有异常发生
	
	//写端口
	input wire							LLbit_i,	//要写到LLbit寄存器的值
	input wire                    we,		//是否要写LLbit寄存器
	
	//读端口1
	output reg                    LLbit_o	//LLbit寄存器的值
	
);

	always @ (posedge clk) begin
		if (rst == `RstEnable) begin
			LLbit_o <= 1'b0;
		end 
		else if((flush == 1'b1)) begin	//如果异常发生，设置为0
			LLbit_o <= 1'b0;
		end 
		else if((we == `WriteEnable)) begin
			LLbit_o <= LLbit_i;
		end
	end

endmodule

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

				`EXE_LL_OP:		begin
					mem_addr_o <= mem_addr_i;
					mem_we <= `WriteDisable;
					wdata_o <= mem_data_i;	
					LLbit_we_o <= 1'b1;
					LLbit_value_o <= 1'b1;
					mem_sel_o <= 4'b1111;			
					mem_ce_o <= `ChipEnable;						
				end	

				`EXE_SC_OP:		begin
					if(LLbit == 1'b1) begin
						LLbit_we_o <= 1'b1;
						LLbit_value_o <= 1'b0;
						mem_addr_o <= mem_addr_i;
						mem_we <= `WriteEnable;
						mem_data_o <= reg2_i;
						wdata_o <= 32'b1;
						mem_sel_o <= 4'b1111;		
						mem_ce_o <= `ChipEnable;				
					end 
					else begin
						wdata_o <= 32'b0;
					end
				end

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

时雨咕噜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RK3568移植linux qt和RT-rthread
wangjie36的博客
07-01 1365
先编译RT-Thread源码，并导出应用模块开发环境，再进行对应的应用APP代码编写和编译。首先在env中输入scons --target=ua ，生成当前bsp的用户程序开发环境， 进入/rt-thread-amp/bsp/rk3568_dlmodule目 录 ， 先执行.\set_env.bat脚本进行环境配置。rk3568_dlmodule存放有00_so和01_mo，分别为动态库和应用模块，可以分别使用scons --lib=00_so和scons –app=01_mo命令来编译动态库和应用模块。
自己动手写CPU之第九阶段（1）——加载存储指令说明1
leishangwen的专栏
10-08 7904
MIPS32指令集架构中定义的加载存储指令共有14条，其中8条加载指令：lb、lbu、lh、lhu、ll、lw、lwl、lwr，6条存储指令：sb、sc、sh、sw、swl、swr，本文介绍了除lwl、lwr、swl、swl外的10条指令的含义及其作用。
第九章 加载存储指令的实现
dieyouxiu的博客
01-30 3995
本章将实现MIPS32指令集架构中定义的加载存储指令，分两步：首先实现除ll、sc指令外的一般加载存储指令，其次实现比较特殊的加载存储指令ll、sc。 9.1 加载存储指令说明 MIPS指令集架构中定义的加载存储指令共有14条，如下： 9.1.1 加载指令lb,lbu,lh,lhu,lw说明 加载指令lb,lbu,lh,lhu,lw说明 从图中可知，这5条加载指令可以根据指令中26-31bit的指令码加以区分，另外，加载指令的第0-15bit是offset，第21-15bit是base，加载地址的计算方
or1200中加载存储类指令说明
leishangwen的专栏
05-07 1497
以下内容摘自《步步惊芯——软核处理器内部设计分析》一书       OR1200中实现的加载存储类指令有8条，每条指令的作用与说明如表9.1所示。       说明一点：在第2章建立的最小系统没有配置使用MMU，所以有效地址等于物理地址。       加载存储类指令的助记符也很好理解记忆，第一位是’s’表示存储指令，’l’表示加载指令；第二位是’b’表示对字节操作
多寄存器加载/存储指令的8种模式
急需成长的路
05-06 1730
多寄存器加载/存储指令的8种模式如下表所示，右边四种为堆栈操作、左边四种为数据传送操作。   模式 说明                 模式 说明 IA 每次传送后地址加4 FD 满递减堆栈 IB 每次传送前地址加4 ED 空递减堆栈 DA 每次传送后地址减4 FA 满递增堆栈 DB 每次传送前地址减4 EA 空递增堆栈 数据块传送操作                 堆栈操作 进行
18.2 字节码指令集与解析举例 - 加载与存储指令
u013559614的博客
07-30 367
加载和存储指令用于将数据从栈帧的局部变量表和操作数栈之间来回传递。上面所列举的指令助记符中，有一部分是以尖括号结尾的（例如iload_）。这些指令助记符实际上代表了一组指令（例如iload_代表 了iload_0、iload_1、iload_2和iload_3这几个指令）。这几组指令都是某个带有一个操作数的通用指令（例如iload） 的特殊形式，对于这若干组特殊指令来说，它们表面上没有操作数，不需要进行取操作数的动作，但操作数都隐含在指令中。...
No.09 加载存储指令的实现1
08-08
【加载存储指令详解】 在MIPS架构中，加载存储指令用于在内存和寄存器之间传输数据。本文主要探讨的是非对齐地址下存储一个字的实现，涉及到的指令包括lb、lbu、lh、lhu、lw（加载指令）以及sb、sh、sw（存储指令）...
vue指令实现页面图片懒加载鼠标滚动图片开始加载
12-01
Vue 指令是Vue.js框架提供的一种自定义行为方式，通过创建自定义指令，我们可以实现图片懒加载功能，即当图片进入浏览器视口时才开始加载，这样可以有效地节省带宽，提高页面的加载速度。 图片懒加载的核心原理在于...
实验九 ARM数据处理指令数据加载存储指令实验.docx
05-21
实验九 ARM数据处理指令数据加载存储指令实验
CPU基本指令的实现
04-12
PC是一个寄存器，用于存储当前要执行指令的地址。在执行完一条指令后，PC通常会自动递增，以便指向下一条指令的地址，这是顺序执行的基础。然而，在某些情况下，如分支、跳转等指令，我们需要改变PC的值，这就是PRSE...
JAVA字节码指令集（加载存储指令）
k0bin的博客
02-06 797
1.加载和存储指令 加载和存储指令用于将数据从栈帧的本地变量表和操作数栈之间来回传递 将本地变量加载到操作数栈的指令（本地变量-&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;操作数栈）: iload ...
10.加载与存储指令(load、const、push、lcd、store系列)
simpleGq的专栏
12-23 2800
目录1.加载与存储指令概述2.操作数栈和局部变量表复习2.1 操作数栈2.2 局部变量表 1.加载与存储指令概述 作用：加载与存储指令用于将数据从栈帧的局部变量和操作数栈之间来回传递。 将一个局部变量加载到操作数栈：xload、xload_<n>，其中<n>为0-3。 将一个常量加载到操作数栈：bipush、sipush、ldc、iconst_<n>等，其中<n>为0-3。 将一个数值从操作数栈存储到局部变量表：xstore、xstore_<n>
ARM的六大类指令集--- 加载/存储指令
ouzhouren的专栏
06-27 660
zhuanzi ARM微处理器支持加载/存储指令用于在寄存器和存储器之间传送数据，加载指令用于将存储器中的数据传送到寄存器，存储指令则完成相反的操作。常用的加载存储指令如下：     —  LDR     字数据加载指令 —       LDRB    字节数据加载指令     —  LDRH    半字数据加载指令     —  STR     字数据存储指令 —       STR
加载/存储指令
weixin_34019929的博客
01-11 482
加载/存储指令 ARM微处理器支持加载/存储指令用于在寄存器和存储器之间传送数据，加载指令用于将存储器中的数据传送到寄存器，存储指令则完成相反的操作。常用的加载存储指令如下： 1、LDR 指令 LDR 指令的格式为： LDR{条件} 目的寄存器，<存储器地址> LDR 指令用于从存储器中将一个32 位的字数据传送到目的寄存器中。该指令通常用于从存储...
数据加载与存储指令概述
weixin_34195546的博客
09-19 440
ARM 处理器是加载/ 存储体系结构的处理器，对存储器的访问只能通过加载和存储指令实现。 　　1.　数据加载与存储的方向问题 　　　　数据加载与存储（ Load-store ）指令用于在存储器和处理器的寄存器之间传送数据。 　　　　数据加载与存储指令共有三种类型：单寄存器加载与存储指令、多寄存器加载与存储指令和交换指令。 　　2.　数据加载与存储指令的寻址 数据加载与存...
加载与存储指令概述
实践求真知
08-07 529
一作用 加载和存储指令用于将数据从栈帧的局部变量表和操作数栈之间来回传递。 二常用指令图解 三小结 上面所列举的指令助记符中，有一部分是以尖括号结尾的（例如 iload_<n>）。这些指令助记符实际上代表一组指令（例如 iload_<n>代表了 iload_<0>、iload_<1>、iload_<2>、iload_<3>这几个指令）。这几个指令都是带有一个操作数的通用指令（例如 iload）的特殊形式，对于这若干...
【五级流水线CPU】—— 6. 加载存储指令(14)
Running Snail
09-30 1549
文章目录1. 初步 12条1.1 分析1.2 添加数据存储器RAM1.3 修改最小SOPC2.3 测试9 加载存储指令2. load-use数据冒险测试10 load-use数据冒险的解决 1. 初步 12条 1.1 分析 加载指令实现思路 加载指令在译码阶段进行译码，得到运算类型 alusel o、 aluop_o，以及要写的目的寄存器信息。这些信息传递到执行阶段，然后又传递到访存阶段，访存阶段依据这些信息，设置对数据存储器RAM的访问信号。从RAM读取回来的数据需要按照加载指令的类型、加载地址进行对齐调
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中.zip
07-31
Java面试整理，涵盖基础、JVM、线程并发、框架、MySQL、微服务、Redis、中间件、数据结构与算法等。陆续完善中
chromedriver-mac-x64_121.0.6167.184.zip
最新发布
07-31
chromedriver-mac-x64_121.0.6167.184.zip
MIPS指令系统：加载存储指令详解与非对齐访问
本文主要介绍了MIPS架构中的加载存储指令，包括常规的加载存储指令以及特殊的ll、sc指令。文章重点讲述了非对齐地址存储字的实现，特别是lwl和lwr指令的用法。 MIPS加载存储指令分为加载（Load）和存储（Store）两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值