Question

我必须创建一个简单的基于堆栈的机器。指令集由5条指令组成;推，弹，添加，多，结束。我接受一个包含指令部分（.text）和数据部分（.data）的源代码文件，然后我必须通过模拟使用32位地址的内存系统将它们存储在内存中。

我必须存储在内存中的示例源代码文件可能是

    .text
main:
    push X
    push Y
    add   //remove top two words in stack and add them then put result on top of stack
    pop (some memory address)  // stores result in the address
    end

    .data
X:  3    // allocate memory store the number 3
Y:  5

关于如何进行内存系统的任何建议？我应该将数据存储在一个部分（可能是一个数组？）然后将指令存储在另一个部分中，但我不能只使用数组索引，因为我需要在我的代码中使用32位地址。

编辑：一旦我将数字3和5分配给内存空间（在我的数据数组中），还有办法用实际地址替换X和Y吗？。。。有点像两通汇编程序可能会这样做。

Answer 1

数组有什么问题？如果你知道你需要的尺寸，他们应该工作。
机器代码中的地址实际上是数组中的索引。

将32位索引与数组一起使用不是问题。当然，并非所有索引都有效 - 只有从0到数组大小的索引才有效。但是你需要模拟4GB内存，还是可以设置内存大小限制？

Answer 2

只是添加到ugoren的答案（并且有点OT），我认为一个相对有趣的方法可能是使用.stack部分扩展您的规范空间，默认情况下初始化为空（如in你的例子。）

可以用来描述计算的预期中间阶段（在某一点保存/恢复实际状态）。

要实现，我会使用非常简单的代码，比如

file stack.h：

#ifndef STACK
#define STACK

#include <stdio.h>

/* here should be implemented the constraint about 32 bits words... */
typedef int word;

typedef struct { int top; word* mem; int allocated; } stack;
typedef stack* stackp;

stackp new_stack();
void free_stack(stackp);

void push(stackp s, word w);
word pop(stackp p);

/* extension */
stackp read(FILE*);
void write(stackp, FILE*);

#endif

file stack.c：

/* example implementation, use - arbitrary - chunks of 2^N */

#include <stdlib.h>
#include "stack.h"

/* blocks are 256 words */
#define N (1 << 8)

stackp new_stack() {
  stackp s = calloc(1, sizeof(stack));
  s->mem = malloc((s->allocated = N) * sizeof(word));
  return s;
}
void free_stack(stackp s) {
  free(s->mem);
  free(s);
}

void push(stackp s, int w) {
  if (s->top == s->allocated) {
     s->allocated += N;
     s->mem = realloc(s->mem, s->allocated * sizeof(word));
  }
  s->mem[s->top++] = w;
}
word pop(stackp s) {
  if (s->top == 0) { /* exception */ }
  return s->mem[--(s->top)];
}

文件main.c：

#include "stack.h"
int main() {

  stackp s = new_stack();
  word X = 3;
  word Y = 5;

  push(s, X);
  push(s, Y);
  word Z = pop(s) + pop(s);

  printf("Z=%d\n", Z);

  free_stack(s);
}

文件makefile：

main: main.c stack.c

构建：

make

进行测试：

./main
Z=8

值得注意的是WRT ugoren的回答：我强调数据隐藏，这是实现的重要部分，将实际功能的详细信息保存在单独的文件中。在那里我们可以添加许多细节，例如关于最大堆栈大小（实际上没有强制执行），错误处理等...

编辑：获取推送词的“地址”

word push(stackp s, int w) {
  if (s->top == s->allocated) {
     s->allocated += N;
     s->mem = realloc(s->mem, s->allocated * sizeof(word));
  }
  s->mem[s->top] = w;
  return s->top++;
}

Answer 3

内存系统的关键是限制内存的范围。在OS中，您只能访问内存的几个部分。

因此，在您的特定程序中，您可以说，有效程序可以包含从0x00004000开始的收件人，并且您的计算机可用的内存例如是4 MB。

然后在你的程序中创建大小为4MB的虚拟内存空间并将其存储起来。

以下是一个例子;请记住这是一个例子，你必须相应地调整参数。

virtual memory start - 0x00006000 (get from malloc, or static initialization. or whatever)
stack machine memory start - 0x00004000
offset - 0x2000 (to align addresses in you OS and in your stack machine, you have to add 0x2000 to the stack machine address to get pointer to your array (in reality the offset can be negative).

如果您确实需要索引到数组，只需从指针中减去虚拟内存的开头。

C中简单的基于堆栈的机器

3 个答案: