精华内容
下载资源
问答
  • 包含MULT、MULTU的v文件以及对应的testbank文件,代码带注释。
  • Verilog 32位booth乘法

    2019-09-30 22:38:53
    32位有符号Booth乘法器,用Verilog代码实现,只是初级的设计。
  • 用16位乘法指令完成32位无符号乘法
  • 微机课设32位无符号数乘法代码,完成了输入和输出的去0操作
  • 大学期间微机原理的课设,通过使用汇编语言,用16位乘法指令实现32位无符号数乘法的程序,希望能为后来者提供一些启发
  • 高位数乘法是指乘数多余32位的乘法,一般情况下,计算机操作系统自带的计算器产生溢出,本程序可以最高计算4千位以上。本程序开发环境Delphi 7.0,没有第三方控件,文件完整。
  • 微机原理课设程序设计
  • 32位的乘法

    2014-08-22 21:20:22
    此代码利用移位法实现了乘法器,并且对带时钟的进行了改进,分为同步和异步两种,仿真测试没有漏洞。
  • 32x32Booth乘法

    千次阅读 2019-09-30 21:49:47
    本设计是一个简单的基于Booth算法的32位有符号数乘法器,Booth算法的原理是先判断P[1:0],然后操作P空间,最后P空间移位,根据P空间的最高位来给移位后的P选择补1 or 补0。 booth乘法器是一种位操作乘法器,与传统...

    32x32Booth乘法器

    本设计是一个简单的基于Booth算法的32位有符号数乘法器,Booth算法的原理是先判断P[1:0],然后操作P空间,最后P空间移位,根据P空间的最高位来给移位后的P选择补1 or 补0。
    booth乘法器是一种位操作乘法器,与传统乘法器不同的是直接操作位。booth有一个重要的加码运算。

    p[0]p[-1]加码结果
    00无操作,右移一位
    01+被乘数,右移一位
    10-被乘数,右移一位
    11无操作,右移一位
    module booth(
        input [31:0]A,
        input [31:0]B,
        input clk,
        input rst,
        input sig,
        output [63:0]Booth,
        output done,
        output [5:0]X
    
        );
    reg [5:0]i;
    reg [64:0]p;
    reg [31:0]a;
    reg [31:0]s;
    reg [5:0]x;
    reg isdone;
    
    always@(posedge clk or negedge rst)
      if(!rst)
       begin
         i<=6'b0;
         p<=65'b0;
         a<=32'b0;
         s<=32'b0;
         x<=0;
         isdone<=0;
       end
      else if(sig)
       begin
        case(i)
          0:
           begin
             a<=A;
             s<=~A+1'b1;
             p<={32'b0,B,1'b0};
             i<=i+1;
             isdone<=0;
           end
          1:
           begin
             if(x==32)
                begin
                 x<=0;
                 i<=i+2;
                end
             else if(p[1:0]==2'b01)
                begin
                 p<={p[64:33]+a,p[32:0]};
                 i<=i+1;
                end
             else if(p[1:0]==2'b01)
                begin
                 p<={p[64:33]+s,p[32:0]};
                 i<=i+1;
                end
             else
                begin
                 p<=p;
                 i<=i+1;
                end
          2:
          begin
            p<={p[64],p[64:1]};
            x<=x+1;
            i<=i-1;
       
          3:
           begin isdone<=1;i<=i+1;end
          4:
           begin isdone<=0;i<=0;end
         endcase
       end
    assign done=isdone;
    assign Booth=p[64:1];
    assign X=x;
    endmodule   
    
    
    
    
    展开全文
  • 汇编程序:32位无符号数乘法

    万次阅读 热门讨论 2017-05-13 08:15:47
    【任务】用十六位乘法指令完成三十二位无符号数乘法(结果64位),数据用下面的内存单元提供:ddata segment x1 dw 5678H x2 dw 1234H y1 dw 0DEF0H y2 dw 9ABCH xy dw 4 dup (?) ddata ends其中,被乘数x=((x2...

    【任务】用十六位乘法指令完成三十二位无符号数乘法(结果64位),数据用下面的内存单元提供:

    ddata segment
          x1 dw 5678H
          x2 dw 1234H
          y1 dw 0DEF0H
          y2 dw 9ABCH
          xy dw 4 dup (?)
    ddata ends

    其中,被乘数x=((x2)*2^16)+(x1),即x2是高16位,x1是低16位;乘数y=((y2)*2^16)+(y1),即y2是高16位,y1是低16位。
    【分析】
    将把32位的被乘数的乘法分别分割成2个16位的数,分别对其进行16位的乘法,然后将得到的4个16位乘法的乘积,按照各自的位相加的最终乘积,如下图:
    这里写图片描述
    【参考解答】

    assume cs:ccode, ds:ddata
    ddata segment
          x1 dw 5678H
          x2 dw 1234H
          y1 dw 0DEF0H
          y2 dw 9ABCH
          xy dw 4 dup (?)
    ddata ends
    ccode segment
    start:mov ax,ddata
          mov ds,ax
    
          mov ax,x1
          mov dx,y1
          mul dx
          mov [xy],ax
          mov [xy+2],dx     ;被乘数低位4字符x1和乘数低位4字符y1相乘结果低位存入xy,高位存入xy+2
    
          mov ax,x2
          mov dx,y1
          mul dx
          add [xy+2],ax
          adc [xy+4],dx      ; 被乘数高位4字符x2和乘数低位4字符y1相乘结果低位存入xy+2,高位存入xy+4
    
          mov ax,x1
          mov dx,y2
          mul dx
          add [xy+2],ax
          adc [xy+4],dx
          adc [xy+6],0       ; 被乘数低位4个字符x1和乘数高位4个字符y2相乘结果低位存入xy+2,高位存入xy+4
    
          mov ax,x2
          mov dx,y2
          mul dx
          add [xy+4],ax
          adc [xy+6],dx      ; 被乘数高位4个字符x2和乘数高位4个字符y2相乘结果低位存入xy+4,高位存入xy+6
    
          mov ah,4ch
          int 21h
    
    ccode ends
    end start
    展开全文
  • 超大数乘法

    2018-08-22 23:42:25
    最大支持32767位数字与32767位数字相乘得到一个65534位数的结果
  • 16位寄存器完成 32位数的乘法 汇编 非常好 答辩 5个班 唯一的 优+
  • 32位数汇编语言乘法

    2010-05-19 11:57:20
    32位汇编语言乘法 这个乘法好啊 算法简单啊 希望大家喜欢啊
  • ARM有两类乘法指令:一类为32位的乘法指令,即乘法操作的结果为32位;另一类为64位的乘法指令,即乘法操作的结果为64位。  (1)MUL 32乘法指令  MUL提供32位整数乘法。如果操作是有符号的,则可以假定结果...
  • 微机原理课程设计,32乘以32无符号数乘法和递归调用算法实例
  • 实现32位补码乘。设计的很金典,拿来与大家共享
  • 汇编语言完成32位乘以32乘法。适合学生实验,课程设计。
  • 设计计算两个32位的无符号乘法的程序。
  • 分析其可能需要的微指令类型,结合龙腾C2的微体系结构,对执行部件以及译码部件工作作出权衡,同时又考虑到旁路设计的需求,设计出适应不同乘法指令类型及结果时机需求的三级流水32位有符号、无符号混合树型乘法器...
  • 32乘法器和除法器

    千次阅读 2020-11-20 19:56:59
    32乘法器和除法器32乘法器和除法器的设计与实现乘法器原理除法器原理乘法器代码除法器代码乘除法器顶层模块代码(包含拨码输入以及数码管输出)约束文件修改 32乘法器和除法器的设计与实现 乘法器原理 类比10...

    32位乘法器和除法器的设计与实现

    乘法器原理

    类比10进制乘法,利用移位运算。每次对两因数中的一个的第一位进行判断,一共判断32位共循环32次,若该位为1,则将积加上另一因数,若为0,则不用加。每次循环结束将用于判断的因数右移一位,用于和积相加的因数左移一位,循环完成后,积即为两因数的积。
    在这里插入图片描述

    除法器原理

    类比十进制除法,利用移位运算。将被除数前32位拼接上32位的0,一共判断32位共循环32次,每次比较被除数前32位与除数相比,若大于除数,则将被除数前32位减去除数,并将整个64位的被除数加上1,若小于除数,则什么也不做,每次循环完成后将被除数左移一位。循环完成后,被除数前32位为余数,后32位为商。

    在这里插入图片描述

    乘法器代码

    module mult32(
        input wire [31:0] a,
        input wire [31:0] b,
        output reg [63:0]p
        );
        reg [63:0] pv;
        reg [63:0] ap;
        integer i;
    
        always@(*)
            begin
                pv=64'b0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000;
                ap={32'b0000_0000_0000_0000_0000_0000_0000_0000,a};
                for(i=0;i<=31;i=i+1)
                    begin
                        if(b[i]==1)
                            pv=pv+ap;
                            ap={ap[62:0],1'b0};
                    end
                p=pv;
            end
    endmodule
    

    除法器代码

    module div32(
        input[31:0] a,   
        input[31:0] b,  
        
        output reg [31:0] yshang,  
        output reg [31:0] yyushu  
        );  
        
        reg[31:0] tempa;  
        reg[31:0] tempb;  
        reg[63:0] temp_a;  
        reg[63:0] temp_b;  
        
        integer i;  
        
        always @(a or b)  
        begin  
            tempa <= a;  
            tempb <= b;  
        end  
        
        always @(tempa or tempb)  
        begin  
            temp_a = {32'h00000000,tempa};  
            temp_b = {tempb,32'h00000000};   
            for(i = 0;i < 32;i = i + 1)  
                begin  
                    temp_a = {temp_a[62:0],1'b0};  
                    if(temp_a[63:32] >= tempb)  
                        temp_a = temp_a - temp_b + 1'b1;  
                    else  
                        temp_a = temp_a;  
                end  
        
            yshang <= temp_a[31:0];  
            yyushu <= temp_a[63:32];  
        end  
        
    endmodule  
    

    乘除法器顶层模块代码(包含拨码输入以及数码管输出)

    module mult_div_top(
        input clk,
        input [15:0] sw,
        output reg [6:0] a_to_g,
        output reg [3:0] an,
        output reg [3:0] led,
        output wire dp
        );
    
        reg [31:0] a;
        reg [31:0] b;
        wire [63:0] mult;
        wire [63:0] div;
        reg [15:0] disp;
    
        always@(sw[15:8])
            begin
                if(sw[15]==0)
                    case(sw[14:13])
                        2'b00:a[31:24]=sw[7:0];
                        2'b01:a[23:16]=sw[7:0];
                        2'b11:a[15:8]=sw[7:0];
                        2'b10:a[7:0]=sw[7:0];
                        default:;
                    endcase
    
                else if(sw[15]==1)
                    case(sw[14:13])
                        2'b00:b[31:24]=sw[7:0];
                        2'b01:b[23:16]=sw[7:0];
                        2'b11:b[15:8]=sw[7:0];
                        2'b10:b[7:0]=sw[7:0];
                        default:;
                    endcase
            end
    
        always@(*)
            begin
                if(sw[8]==0)
                    case(sw[10:9])
                        2'b00:
                            begin
                                disp=mult[63:48];
                                led=4'b1000;
                            end
                        2'b01:
                            begin
                                disp=mult[47:32];
                                led=4'b0100;
                            end
                        2'b11:
                            begin
                                disp=mult[31:16];
                                led=4'b0010;
                            end
                        2'b10:
                            begin
                                disp=mult[15:0];
                                led=4'b0001;
                            end
                        default:
                            begin
                                disp=16'b0000_0000_0000_0000;
                                led=4'b0000;
                            end
                            
                    endcase
    
                else if(sw[8]==1)
                    case(sw[10:9])
                        2'b00:
                            begin
                                disp=div[63:48];
                                led=4'b1000;
                            end
                        2'b01:
                            begin
                                disp=div[47:32];
                                led=4'b0100;
                            end
                        2'b11:
                            begin
                                disp=div[31:16];
                                led=4'b0010;
                            end
                        2'b10:
                            begin
                                disp=div[15:0];
                                led=4'b0001;
                            end
                        default:
                            begin
                                disp=16'b0000_0000_0000_0000;
                                led=4'b0000;
                            end
                            
                    endcase
                
            end
    
        mult32 multiply(
            .a(a),
            .b(b),
            .p(mult)
        );
    
        div32 divide(
            .a(a),
            .b(b),
            .yshang(div[63:32]),
            .yyushu(div[31:0])
        );
    
    
        wire [15:0]x;
        assign x=disp;
        wire [1:0] s;
        reg [3:0] digit;
        reg [19:0] clkdiv;
        assign dp=1;
        assign s=clkdiv[19:18];
        assign ane=4'b1111;
        always@(*)
            case(s)
                0:digit=x[3:0];
                1:digit=x[7:4];
                2:digit=x[11:8];
                3:digit=x[15:12];
                default:digit=x[3:0];
            endcase
        always@(*)
            case(digit)
                0:a_to_g=7'b0000001;
                1:a_to_g=7'b1001111;
                2:a_to_g=7'b0010010;
                3:a_to_g=7'b0000110;
                4:a_to_g=7'b1001100;
                5:a_to_g=7'b0100100;
                6:a_to_g=7'b0100000;
                7:a_to_g=7'b0001111;
                8:a_to_g=7'b0000000;
                9:a_to_g=7'b0000100;
                'hA:a_to_g=7'b0001000;
                'hB:a_to_g=7'b1100000;
                'hC:a_to_g=7'b0110001;
                'hD:a_to_g=7'b1000010;
                'hE:a_to_g=7'b0110000;
                'hF:a_to_g=7'b0111000;
                default: a_to_g=7'b0000001;
            endcase
        always@(*)
        begin
            an=4'b1111;
            an[s]=0; 
        end
        always@(posedge clk)
        begin
                clkdiv<=clkdiv+1; 
        end
    
    endmodule
    
    

    约束文件修改

    直接IO Planning之后Run Implementation会出现’IO Clock Placer failed’
    需要在约束文件中加上

    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets sw] 
    

    了解更多
    了解更多
    以下是我的约束文件(板子型号BASYS3)

    set_property IOSTANDARD LVCMOS33 [get_ports clk]
    set_property PACKAGE_PIN W5 [get_ports clk]
    set_property IOSTANDARD LVCMOS33 [get_ports dp]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[15]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[14]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[13]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[12]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[11]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[10]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[9]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[8]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[7]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[6]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[5]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[4]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[3]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[2]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[1]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {sw[0]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {led[3]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {led[2]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {led[1]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {led[0]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {an[3]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {an[2]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {an[1]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {an[0]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[6]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[5]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[4]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[3]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[2]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[1]}]
    set_property IOSTANDARD LVCMOS33 [get_ports {a_to_g[0]}]
    set_property PACKAGE_PIN W7 [get_ports {a_to_g[6]}]
    set_property PACKAGE_PIN W6 [get_ports {a_to_g[5]}]
    set_property PACKAGE_PIN U8 [get_ports {a_to_g[4]}]
    set_property PACKAGE_PIN V8 [get_ports {a_to_g[3]}]
    set_property PACKAGE_PIN U5 [get_ports {a_to_g[2]}]
    set_property PACKAGE_PIN V5 [get_ports {a_to_g[1]}]
    set_property PACKAGE_PIN U7 [get_ports {a_to_g[0]}]
    set_property PACKAGE_PIN W4 [get_ports {an[3]}]
    set_property PACKAGE_PIN V4 [get_ports {an[2]}]
    set_property PACKAGE_PIN U4 [get_ports {an[1]}]
    set_property PACKAGE_PIN U2 [get_ports {an[0]}]
    set_property PACKAGE_PIN L1 [get_ports {led[3]}]
    set_property PACKAGE_PIN P1 [get_ports {led[2]}]
    set_property PACKAGE_PIN N3 [get_ports {led[1]}]
    set_property PACKAGE_PIN P3 [get_ports {led[0]}]
    set_property PACKAGE_PIN R2 [get_ports {sw[15]}]
    set_property PACKAGE_PIN T1 [get_ports {sw[14]}]
    set_property PACKAGE_PIN U1 [get_ports {sw[13]}]
    set_property PACKAGE_PIN W2 [get_ports {sw[12]}]
    set_property PACKAGE_PIN R3 [get_ports {sw[11]}]
    set_property PACKAGE_PIN T2 [get_ports {sw[10]}]
    set_property PACKAGE_PIN T3 [get_ports {sw[9]}]
    set_property PACKAGE_PIN V2 [get_ports {sw[8]}]
    set_property PACKAGE_PIN W13 [get_ports {sw[7]}]
    set_property PACKAGE_PIN W14 [get_ports {sw[6]}]
    set_property PACKAGE_PIN V15 [get_ports {sw[5]}]
    set_property PACKAGE_PIN W15 [get_ports {sw[4]}]
    set_property PACKAGE_PIN W17 [get_ports {sw[3]}]
    set_property PACKAGE_PIN W16 [get_ports {sw[2]}]
    set_property PACKAGE_PIN V16 [get_ports {sw[1]}]
    set_property PACKAGE_PIN V17 [get_ports {sw[0]}]
    set_property PACKAGE_PIN U16 [get_ports dp]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets clk]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets {sw[8]}]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets {sw[9]}]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets {sw[10]}]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets {sw[13]}]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets {sw[14]}]
    set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets {sw[15]}]
    
    展开全文
  • 32×32高速乘法器的设计与实现.pdf
  • WinMIPS64 32乘法器&除法器 模拟实验 文章目录WinMIPS64 32乘法器&除法器 模拟实验一、实验内容二、实验环境三、实验步骤1. 忽略溢出的乘法器2. 溢出提示的乘法器3. 基础除法器的实现4. 乘除中正负号的...

    WinMIPS64之32位乘法器和除法器的模拟实验

    一、实验内容

    • 第一部分:用加法器设计一个不考虑溢出的乘法器
    • 第二部分:用加法器设计一个考虑溢出的乘法器
    • 第三部分:用减法器设计一个除法器 (额外尝试)

    二、实验环境

    硬件:桌面PC

    软件:Windows,WinMIPS64仿真器

    三、实验步骤

    1. 忽略溢出的乘法器

    总共分为4步:

    1. 测试乘数最低位是否为1,是则给乘积加上被乘数,将结果写入乘积寄存器;
    2. 被乘数寄存器左移1位;
    3. 乘数寄存器右移一位;
    4. 判断是否循环了32次,如果是,则结束,否则返回步骤1。

    图0 乘法流程说明图

    根据上面的步骤,当结果小于32位时,结果正常;当结果大于32位时,结果只截取了低32位的结果,而高32位的结果直接忽略掉了。

    思路:首先将输入的数据在内存中指定的方式固定输入,主要通过上述4步实现忽略溢出的乘法逻辑,在程序运行结束后观察目标寄存器的值。最后完善输入和输出即可。

    • 固定输入时

    图 1 乘法逻辑的实现

    通过asm.exe检测语法无误后在winmips64上执行结果如下,可以观察到此时r5寄存器的值已经变为f,即实现乘法逻辑。

    图 2 初步结果

    • 将输入改为用户输入,增加输出部分:

    输入和输出部分都需要操作Control和Data中的值,开始部分的修改如下:

    图 3 忽略溢出的乘法器代码(一)

    中间的循环体依旧保持不变:

    图 4 忽略溢出的乘法器代码(二)

    最后输出提示语以及结果即可:

    图 5 忽略溢出的乘法器代码(三)

    • 验证结果如下:

    图 6 验证结果(一)

    图 7 验证结果(二)

    2. 溢出提示的乘法器

    思路:基于第一个忽略溢出的乘法器做优化,这个小优化是十分简单的,只需要对64位的寄存器中的高32位进行检测即可。当高32位为0时,说明结果没有溢出,否则,结果溢出。

    溢出提示只需要额外设置提示字符串Str3以及右移最终的结果32位观察高位是否为0即可,若为0,则无溢出,若不为0,则发生溢出。

    图 8 溢出提示的乘法器

    注意不能直接右移立即数32位,编译不允许。其中在.data区域额外声明警告字符串:

    .data
    STR3: .asciiz "warning: result overflow\n";
    

    分别测试非溢出状态以及溢出状态的乘法器结果如下:

    图 9 溢出提示乘法器结果(一)

    图 10 溢出提示乘法器结果(二)

    可以见到,当存储结果的R5寄存器高32位的值非0,故R20也非0,程序输出溢出提示。

    3. 基础除法器的实现

    思路1:通过比较大小累减获得商和余数

    a、比较被除数和除数的大小;

    b、如果被除数比较大,将被除数减去除数,商加1;

    c、循环步骤a和b,直到被除数比除数小,这时候被除数剩下的就是余数,商就是结果(初值为0)。

    思路2:通过移位累减获得商和余数

    a、比较被除数和n*除数的大小;(其中n为移位的位数,可以理解为步骤一中一次性减掉的除数)

    b、如果被除数比较大,将被除数减去n*除数,商加n;

    c、循环步骤a和b,直到被除数比1*除数小,这时候被除数剩下的就是余数,商就是结果(初值为0)。

    显然,思路2 使用移位的操作是基于思路一的步骤的,效率比思路 1 快许多。当除数很小时(比如1),思路 1 执行的循环体循环次数就会非常多。

    • 无移位的简单除法器

    图 11 基础除法器的实现

    在WinMIPS64中执行,开始时R3,R4,R5分别对应被除数,除数和商:

    图 12 寄存器初始数值

    程序结束后,R3存储余数,R5存储商:

    图 13 运行结果

    显然13÷3 = 4 ……1,验证成功。

    • 移位实现的除法器

    每次被除数减去的除数是从大到小的,所以我们需要在开始的时候将除数放置在 64 位除数寄存器的左半边,然后每次右移一位来和被除数对齐:

    主要代码如下:

    图 14 移位除法

    最终结果如下:

    图 15 除法结果

    至此实现了一个简单的除法器。

    4. 乘除中正负号的处理

    上述实现的乘除法都没有考虑到正负数的情况,如果异号,没有溢出的情况下也会计算错误。

    解决思路:记录两数的符号,同号的结果为正,异号的结果为负。

    分别处理两个输入的数据,如果是负数,则通过取反加一变成正数,得出正确的正数乘除结果;

    最后通过一开始的符号位判断,如果是负数则对计算结果进行取反加一操作。

    注意点:由于 MIPS 指令不支持 NOT ,所以可以通过异或操作来得到相同的结果。

    即 reg xor 0xffff…

    相关代码如下:

    在data区域声明一个ALLONE,表示全都是1。

    .data 
    ALLONE: .word 0xffffffffffffffff
    

    图 16 取反加一操作

    最后通过判断被乘数的符号位(R25)与乘数的符号位(R26)比较是否相同,若不同则进行取反加一的操作(等同于加负号)。

    图 17 最终结果判断

    最终结果如下:

    图 18 运行结果

    四、实验总结

    1. 乘法器的实现

    本次实验了解了通过加法器实现32位乘法器的逻辑,通过累加与位移的循环实现了加法代替乘法。每次某一位上的累加都是基于乘数该位的有与无,而每次位移也体现了该位的权重,越高位的累加,之前的位移数也越多。

    1. 除法器的实现

    本次实验额外尝试的除法器实现与乘法器相比有些不同,虽然不需要判断是否溢出,但是需要提前将除数左移32位,再不断右移。同时左移商与累减被除数。需要注意的是,由于被除数最后会减成余数,故如果需要保存被除数的话需要额外的寄存器。

    1. 更高位的思考

    本次实验由于是使用64位的寄存器实现32位的乘法,所以比较简单。如果需要实现64位的乘法,则 不能使用判断高位的方式 实现,因为需要将乘积放入两个寄存器中,同时需要特判最终结果的符号位。
    与乘法器相比有些不同,虽然不需要判断是否溢出,但是需要提前将除数左移32位,再不断右移。同时左移商与累减被除数。需要注意的是,由于被除数最后会减成余数,故如果需要保存被除数的话需要额外的寄存器。

    展开全文
  • 8位Booth乘法器设计,8位乘8位的基2的booth乘法器的verilog实现。满足1)利用硬件描述语言描述8位数乘法器运算;2)输入为复位信号、乘法执行按键;3)时钟信号为开发板上时钟信号。
  • Verilog实现二进制有符号定点乘法运算

    千次阅读 多人点赞 2020-08-12 15:44:33
    Verilog实现有符号数乘法运算二进制运算原理1、无符号二进制(signed)运算 二进制运算原理 总结最近FPGA的学习,使我明白了一件事:在Verilog程序的编写中,“位”(bit)这一概念,对于程序编写至关重要,...
  • 一、乘法运算 在计算机中,乘法运算是一种很重要的运算,有的机器由硬件乘法器直接...笔算乘法时乘积的符号由两符号心算而:正正正;其数值部分的运算如下: 所以 A×B=+0.10001111 可见,这里包含着被乘数.
  • 计算机组成-无符号数乘法

    万次阅读 2018-08-17 10:02:08
    下面是C语言编写的一个乘法子程序,实现两个16位无符号相乘,结果为32位无符号。 unsigned int mul16(unsigned int x, unsigned int y){ unsigned int a,b,c; unsigned int i; a=x; b=y; c=0; f...
  • 主旨:测试在各种情况下CPU执行10万次乘法耗时 主测试函数: void mutil_10w(void) { u32 mul=0; u16 a=112,b=62; u32 ka=0; for(ka=0;ka&lt;100000;ka++) { mul=a*b; } } 实验1:F103 耗时:22....
  • FPGA 设计32乘法

    千次阅读 2016-05-31 19:44:17
    module mul_32(out,a,b);  input[31:0]a,b;  output[63:0]out;  wire[63:0]out;  assign out=a*b; endmodule module mul_32(out,a,b); input[31:0]a,b; output[63:0]out; wire[63:0]out;
  • 【ARM】乘法指令

    千次阅读 2020-06-16 21:08:58
    两个 32 位二进制相乘的结果是 64 位的积。在有些 ARM 的处理器版本中,将乘积的结果保存到两个独立的寄存器中。另外一些版本只将最低有效 32 位存放到一个寄存器中。无论是哪种版本的处理器,都有乘—累加的变型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,920
精华内容 28,368
关键字:

得数是32的乘法