c语言写cpu

最新推荐文章于 2022-12-27 14:07:04 发布
最新推荐文章于 2022-12-27 14:07:04 发布
阅读量907 收藏 3
点赞数
分类专栏： 计组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GshWooho/article/details/116765680
版权

微型计算机 内存管理 指令执行 寄存器 二进制转换
关键词由CSDN通过智能技术生成 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

unsigned char ram[0x1000];
//采用小端序
//内存32kb，char型1个byte，8个bit
                //0-16383 为代码段
                //16384-32767 为数据段
//memset(ram, 0, sizeof(ram));

short ip = 0; //ip16位可以c寻址32k内存空间

unsigned int ir = 0; //指令寄存器

int flag = 0;

//8个16位寄存器组
short ax[8] = {0};
/*short ax2 = 0;
short ax3 = 0;
short ax4 = 0;
short ax5 = 0;
short ax6 = 0;
short ax7 = 0;
short ax8 = 0;*/

void reset() {
    ip = 0;
    ir = 0;
    flag = 0;
    memset(ax, 0, 8);
    memset(ram, 0, 0x1000);
}

//显示内存状态
void show_cpu_state() {
    printf("ip = %d\n", ip);
    printf("flag = %d\n", flag);
    printf("ir = %08x\n", ir);
    
    printf("ax1 = %d ax2 = %d ax3 = %d ax4 = %d\n", ax[0], ax[1], ax[2], ax[3]);
    printf("ax5 = %d ax6 = %d ax7 = %d ax8 = %d\n", ax[4], ax[5], ax[6], ax[7]);
}

//显示内存数据段与代码段状态
void show_ram_state() {
    int i = 0;
    printf("CodeSegment:");
    for(;i < 64; i++) {
        if(i % 4 == 0)
            printf("\n");
        printf("%02x ", ram[i]);
    }
    printf("\nDataSegment:");
    for(i = 16384; i < 16896; i+=2) {
        int n = 0;
        n += ram[i+1];
        n = n << 8;
        n += ram[i];
        if(i % 32 == 0)
            printf("\n");
        printf("%d ", n);
    }
    printf("\n");
}

//char指令转正2进制形式存储
void str2binary(int index, char instruction[]) {
    int i = index;
    int j = 0;
    for(; j < 4; ++j) {
        int k = j*8;
        char temp[9];
        strncpy(temp, instruction + k, 8);
        //printf("%s Hex:", temp);
        unsigned char n = 0;
        unsigned char t = 0;
        int p = 0;
        int q = 0x80;
        for(; p < 8; ++p) {
            temp[p] -= 0x30;
            t = temp[p] * q;
            q = q >> 1;
            n += t;
        }
        /*temp[0] -= 0x30;
        t = temp[0] * 0x80;
        n += t;
        
        temp[1] -= 0x30;
        t = temp[1] * 0x40;
        n += t;
        
        temp[2] -= 0x30;
        t = temp[2] * 0x20;
        n += t;
        
        temp[3] -= 0x30;
        t = temp[3] * 0x10;
        n += t;
        
        temp[4] -= 0x30;
        t = temp[4] * 0x08;
        n += t;
        
        temp[5] -= 0x30;
        t = temp[5] * 0x04;
        n += t;
        
        temp[6] -= 0x30;
        t = temp[6] * 0x02;
        n += t;
        
        temp[7] -= 0x30;
        t = temp[7] * 0x01;
        n += t;*/
        ram[i] = n;
        //printf("%02x\n", ram[i]);
        ++i;
    }
}

//函数功能：将文件中的指令读入内存的代码段
//输入：文件地址
//输出：无
void instructions_loading(char* fileAddr) {
    FILE *fp;
    fp=fopen(fileAddr,"r");
    char instruction[33],ch[5];
    int i=0;
    while(fgets(instruction,33,fp) != NULL){
        //printf("%s\n", instruction);
        str2binary(4*i, instruction);
        
        fgets(ch, 5, fp);
        //printf("%c", ch);
        i++;
    }
    //printf("%d", i);
    //countl=i;
    fclose(fp);
    return;
}




//函数功能：将代码段中ip指向的指令取出，装入指令寄存器ir
//输入：全局的ip和ram
//输出：无
void load_instruction() {
    ir = 0;
    ir += ram[ip];
    ir = ir << 8;
    ir += ram[ip+1];
    ir = ir << 8;
    ir += ram[ip+2];
    ir = ir << 8;
    ir += ram[ip+3];
    //show_cpu_state();
}

//函数功能：ip指向内存中下一条将要执行的地址
//输入：全局 ip
//输出：无
void inc_ip() {
    ip += 4;
}

//函数功能：分析指令
//输入：ir中的指令
//输出：控制信号
int decode() {
    unsigned int opcode = ir;
    opcode = opcode >> 24;
    switch(opcode) {
        case 0:  return 0;
        case 1:  return 1;
        case 2:  return 2;
        case 3:  return 3;
        case 4:  return 4;
        case 5:  return 5;
        case 6:  return 6;
        case 7:  return 7;
        case 8:  return 8;
        case 9:  return 9;
        case 10:  return 10;
        case 11:  return 11;
        case 12:  return 12;
    }
    return 13;
}

void input(unsigned int func) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    //printf("%d", front-1);
    
    printf("in:\n");
    //setbuf(stdin, NULL);
    
    //printf("%c\n", ch);
    short in;
    //setbuf(stdin, NULL);
    //char ch;
    //scanf("%c", &ch);
    scanf("%hd", &in);
    getchar();
    ax[front-1] = in;
}

void output(unsigned int func) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    
    printf("out:%hd\n", ax[front-1]);
}




void mov(unsigned int func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        printf("front = %d\n", front-1);
        ax[front-1] = imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        ax[front-1] = 0;
        ax[front-1] |= ram[ax[rear-1]+1];
        ax[front-1] = ax[front-1] << 8;
        ax[front-1] |= ram[ax[rear-1]];
    }
    else { // 前内存，后寄存器
        ram[ax[front-1]] = (char)ax[rear-1];
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        short temp = ax[rear-1];
        temp = temp >> 8;
        ram[ax[front-1]+1] = (char)temp;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
}

void add(unsigned int func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] += imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        ax[front-1] += t;
    }
    else { // 前内存，后寄存器
        short t2 = 0;
        t2 |= ram[ax[rear-1]+1];
        t2 = ax[front-1] << 8;
        t2 |= ram[ax[rear-1]];
        t2 += ax[rear-1];
        ram[ax[front-1]] = (char)t2;
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        t2 = t2 >> 8;
        ram[ax[front-1]+1] = (char)t2;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
    
}

void sub(unsigned short func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] -= imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        
        ax[front-1] -= t;
    }
    else { // 前内存，后寄存器
        short t2 = 0;
        t2 |= ram[ax[rear-1]+1];
        t2 = ax[front-1] << 8;
        t2 |= ram[ax[rear-1]];
        
        t2 -= ax[rear-1];
        
        ram[ax[front-1]] = (char)t2;
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        t2 = t2 >> 8;
        ram[ax[front-1]+1] = (char)t2;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
}

void mul(unsigned short func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] *= imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        
        ax[front-1] *= t;
    }
    else { // 前内存，后寄存器
        short t2 = 0;
        t2 |= ram[ax[rear-1]+1];
        t2 = ax[front-1] << 8;
        t2 |= ram[ax[rear-1]];
        
        t2 *= ax[rear-1];
        
        ram[ax[front-1]] = (char)t2;
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        t2 = t2 >> 8;
        ram[ax[front-1]+1] = (char)t2;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
}

void mydiv(unsigned short func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] /= imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        
        ax[front-1] /= t;
    }
    else { // 前内存，后寄存器
        short t2 = 0;
        t2 |= ram[ax[rear-1]+1];
        t2 = ax[front-1] << 8;
        t2 |= ram[ax[rear-1]];
        
        t2 /= ax[rear-1];
        
        ram[ax[front-1]] = (char)t2;
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        t2 = t2 >> 8;
        ram[ax[front-1]+1] = (char)t2;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
}

void and(unsigned short func, short imm) {
    unsigned char temp = (unsigned char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] &= imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        
        ax[front-1] &= t;
    }
    else { // 前内存，后寄存器
        short t2 = 0;
        t2 |= ram[ax[rear-1]+1];
        t2 = ax[front-1] << 8;
        t2 |= ram[ax[rear-1]];
        
        t2 &= ax[rear-1];
        
        ram[ax[front-1]] = (char)t2;
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        t2 = t2 >> 8;
        ram[ax[front-1]+1] = (char)t2;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
}

void or(unsigned short func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] |= imm;
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        
        ax[front-1] |= t;
    }
    else { // 前内存，后寄存器
        short t2 = 0;
        t2 |= ram[ax[rear-1]+1];
        t2 = ax[front-1] << 8;
        t2 |= ram[ax[rear-1]];
        
        t2 |= ax[rear-1];
        
        ram[ax[front-1]] = (char)t2;
        //printf("Mov1:%d\n", ram[ax[front-1]]);
        t2 = t2 >> 8;
        ram[ax[front-1]+1] = (char)t2;
        //printf("Mov2:%d\n", ram[ax[front-1]+1]);
    }
}

void not(unsigned short func) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    if(rear == 0) {
        ax[front-1] = !!(~ax[front-1]);
    }
    else if(rear >= (char)5) { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        t = ax[front-1] << 8;
        t |= ram[ax[rear-1]];
        
        t = ~t;
        ram[ax[rear-1]] = (char)t;
        t = t >> 8;
        ram[ax[rear-1]+1] = (char)t;
    }
    else {
        printf("error!");
        exit(1);
    }
}

void cmp(unsigned short func, short imm) {
    unsigned char temp = (char)func;
    char front = temp >> 4;
    char rear = temp & 0x0f;
    printf("imm=%d\n", imm);
    if(rear == 0) {
        if(ax[front-1] > imm)
            flag = 1;
        else if(ax[front-1] == imm)
            flag = 0;
        else
            flag = -1;
    }
    else { // 前寄存器，后内存
        short t = 0;
        t |= ram[ax[rear-1]+1];
        //printf("1=%x\n",ram[ax[rear-1]+1]);
        t = t << 8;
        t |= ram[ax[rear-1]];
        //printf("2=%x\n", ram[ax[rear-1]]);
        //printf("t:%d\n", t);
        if(ax[front-1] > t)
            flag = 1;
        else if(ax[front-1] == t)
            flag = 0;
        else
            flag = -1;
    }
    
}

void jmp(unsigned short func, short imm) {
    imm -= 4;
    if(func == 0x00) {
        //printf("ip = %d\n", ip);
        ip += imm;
        //printf("imm = %d\n", imm);
    }
    else if(func == 0x01) {
        if(flag == 0)
            ip += imm;
    }
    else if(func == 0x02) {
        if(flag == 1)
            ip += imm;
    }
    else {
        if(flag == -1)
            ip += imm;
    }
}

void halt() {
    show_cpu_state();
    show_ram_state();
    exit(1);
}


//函数功能：执行指令
//输入：控制信号
//输出：
void execute_instrument(int ctrl) {
    unsigned int func = ir;
    //printf("func1=%02x\n", func);
    func = func >> 16;
    //printf("func1=%02x\n", func);
    func = func & 0x00ff;
    short imm = (short)ir;
    printf("func=%02x\n", func);
    switch(ctrl) {
        case 0: {
            //printf("finish!");
            halt();
        }
        case 1: {
            //printf("\nmov");
            mov(func, imm);
            break;
        }
        case 2: {
            //printf("\nadd");
            add(func, imm);
            break;
        }/*
        case 3: {
            printf("\nsub");
            sub(func);
            break;
        }
        case 4: {
            printf("\nmul");
            mul(func);
            break;
        }
        case 5: {
            printf("\ndiv");
            mydiv(func);
            break;
        }
        case 6: {
            printf("\nand");
            and(func);
            break;
        }
        case 7: {
            printf("\nor");
            or(func);
            break;
        }
        case 8: {
            printf("\nnot");
            not(func);
            break;
        }*/
        case 9: {
            //printf("\ncmp");
            cmp(func, imm);
            break;
        }
        case 10: {
            //printf("\njmp");
            jmp(func, imm);
            break;
        }
        case 11: {
            input(func);
            break;
        }
        case 12: {
            output(func);
            break;
        }
    }
}



//函数功能：

int main(int argc, char *argv[]) {
    reset();
    instructions_loading(argv[1]);
    printf("instructions_loading done!\n");
    
    //show_cpu_state();
    //show_ram_state();
    
    int i = 0;
    while(1) {
        i++;
        //printf("%d:\n", i);
        //if(i == 24) // jmp写完了，从jmp下一条开始
          //  break;
        load_instruction();
        
        inc_ip();
        //show_cpu_state();
    
        int ctrl = decode();
    printf("ctrl = %d\n", ctrl);
        
        execute_instrument(ctrl);
        show_cpu_state();
        show_ram_state();
    }
    //show_cpu_state();
    //show_ram_state();
    return 0;
}
GshWooho
关注
专栏目录
C语言检测电脑CPU温度
03-04
在本文中，我们将深入探讨如何使用C语言在Windows操作系统中检测CPU温度。C语言是一种强大的、通用的编程语言，能够直接与系统硬件交互，因此非常适合进行底层系统编程，如CPU温度监测。 首先，我们需要理解CPU温度...
冯多依曼CPU——C语言实现
Strive_LiJiaLe的博客
10-22 473
hahah
CPU类（类的设计）
heliotrope_jin的博客
12-26 1952
【代码】CPU类（类的设计）
三步教你用Verilog写一个CPU：第一步
热门推荐
MarshalRUAN
01-05 1万+
  三步教你用Verilog写一个CPU 第一步：小试牛刀       也许在不少人眼里，这个世界有两座难以企及的大山，一座是操作系统，还有一座就是CPU。无可否认，无论开发一个操作系统还是做一个CPU都是一件极其浩大的工程，需要一个优秀的团队前赴后继的努力。我相信有不少想涉足这两方面的人开始的时候都会有种无从下手的感觉，但是，经过我这一系列CPU的教程之后，我有十足把握，你肯定会...
用C语言实现内存写入
whime
10-29 6949
英特尔CPU迭代: 创建直接写入内存的汇编程序 通过C语言程序调用汇编函数_write_mem8； 由于VRAM写入了15，意味着所有像素颜色使用第15种颜色，所以画面是白色的。 将程序改写使每隔16个像素色号就反复一次，可以呈现条纹图案。 挑战指针 使用C语言指针存储值。 C程序改为 同样可以输出条纹图案如上。 ...
【C 语言】CPU 架构 ( CPU 指令集类型 | CPU 指令类型 | CPU 架构 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
03-19 2568
一、CPU 指令集类型、 二、CPU 指令类型、 三、CPU 架构、 1、x86、 2、ARM、 3、MIPS、 4、PowerPC、
WMI-64- c语言 获取 CPU序列号 CPUID，硬盘序列号 支持64位编译
08-14
【标题】"WMI-64- c语言 获取 CPU序列号 CPUID，硬盘序列号 支持64位编译" 提供了一种在64位环境下使用C语言获取CPU序列号和硬盘序列号的方法。这种方法是通过Windows Management Instrumentation（WMI）技术实现的...
C语言计算代码执行所耗CPU时钟周期
09-03
本文将详细介绍如何使用C语言来计算代码执行所耗的CPU时钟周期，以及这种方法的局限性和注意事项。 首先，我们要知道CPU时钟周期是计算机处理器完成一个基本操作所需的时间，通常以赫兹（Hz）表示，即每秒钟的周期...
c语言查看cpu使用率
01-14
平台：linux。 语言：c。 功能：查看当前系统cpu使用率（可多核），1秒刷新一次。
cpu.rar_32CPU_CPU C语言
09-23
标题中的"cpu.rar_32CPU_CPU C语言"暗示了这是一个关于32位CPU架构以及其与C语言编程相关的资源包。在这个压缩包中，很可能包含有用于理解和操作32位处理器的C语言源代码示例。32位CPU是指能够一次性处理32位数据的...
模拟CPU算术运算的C语言代码
04-22
除了在必要的循环中使用了加法以外，只使用位操作（逻辑与或异或，移位等）模拟CPU的算术运算过程，支持整数与浮点的四则运算，包含字符串与浮点数的转换。
头歌 C# 专题四 类与对象第5节
qq_53679247的博客
01-31 2264
第5关：static静态对象 任务要求 评论28 任务描述 相关知识 static 静态变量的声明和使用 一个实例 特别实例 编程要求 测试说明 任务描述 大学校园内有各种各样的社团，一般每个社团都会不定期举办一些大型活动，活动的时间和地点可能会有所差异。例如某摄影社团2018年上半年活动表： 次数统计 时间 地点 1 2018-03-22 北京大学 2 2018-05-01 中国人民大学 3 2018-06-01 清华大学 本关任务：根据编程要...
C语言CPU——函数
Coulnaut的博客
10-08 1249
函数是C语言的基本模块，通过对函数模块的调用实现特定的功能。 A>函数避免了过长的main函数 B>使代码更美观 C>是可读性更强！ 博文内容 函数的理解 函数的定义——调颜料 函数的参数——元素 参数中的函数——回调函数 函数的进阶——递归 原色红白黑——库函数 综合的运用 #函数的 基础知识 函数的理解 函数并不只是数学那样的函数，一...
设计一个简单的学生信息类
ssbviv的博客
10-26 1万+
设计一个学生信息类 一、任务描述 本关任务：声明并定义一个学生信息类。 二、相关知识 为了完成本关任务，你需要掌握类的声明和定义。 类 在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象，可以利用这些对象的相同特征为它们建立一个集合，而这个集合就称为类。 C++ 中类是把各种不同类型的数据（称为数据成员）和对数据的操作（成员函数）组织在一起而形成的用户自定义的数据类型。它提供了可重用性的好处。 类定义包括声明和实现两大部分。
【转】C语言获取CPU和内存信息
最新发布
m0_60352504的博客
12-27 2114
操作系统和内存信息在windows下通过系统的API来获取，CPU信息则需要需要通过底层CPUID指令取得。
C语言的实现经过（C代码到CPU执行）
布袋和尚
01-05 3141
2018-01-05 创建人：Ruo_Xiao 2018-01-06 修改人：Ruo_Xiao 1、添加编辑器之后，预处理之前的编译器的操作。 2、添加对优化器的简单的说明。 2018-01-12 修改人：Ruo_Xiao 修正最后的逻辑总图，添加“源代码处理”。 2018-01-20 修改人：Ruo_Xiao 增加对编译器和连接器更详细的说明。 一、概括 C源代码 -> C编辑器 -
C语言简单模拟CPU调度算法（FCFS,SJF,HRRF,RR）
一只懒猫的博客
11-08 7359
文章目录一、处理器调度算法简介1、概念解释2、产生原因3、算法优劣性的指标资源利用率：吞吐率：公平性：作业周转时间：二、代码总体思路二、先来先服务（First Come First Serve，FCFS）算法思想：具体代码三、短作业优先（Short Job First，SJF）算法思想代码实现四、高响应比优先（High Response Ratio First，HRRF）算法思想具体实现五、时间片轮转算法（Round-Robin scheduling，RR）算法思想具体实现六、完整项目链接 在学OS的时候，
《自己动手写cpu》读书笔记
lijiuyangzilsc的专栏
05-04 1万+
本文来自《自己动手写cpu》一书的总结。原来自己看过原作者的《步步惊芯--软核处理器分析》以及其他关于or1200的书。本次粗略浏览了该书，就某些感兴趣的部分详细分析，并总结成此文。
C语言虚拟CPU实现及UART通信源码学习指南
资源摘要信息:"该文件涉及了在C语言环境下实现一个虚拟CPU的核心概念与实际编程案例。具体来说，包含了三个主要知识点：Universal Asynchronous Receiver/Transmitter (UART)通信协议、虚拟CPU的设计与实现以及C语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值