help

This is a discussion on help within the C Programming forums, part of the General Programming Boards category; hi, i musst write a programm in C hbut i dont understand this. i dont know how to do it. ...

  1. #1
    Registered User
    Join Date
    Jan 2009
    Posts
    1

    help

    hi,
    i musst write a programm in C hbut i dont understand this. i dont know how to do it. i hope someone can help e.
    i wait for your answer.

    Create a CPU simulator for the model CPU detailed in the lecture Digital Systems. The CPU simulator shall be able to

    load an assembly file provided either at startup as a command-line argument or after invocation via a dedicated command: ld <file>,
    run/execute the program either up to a set breakpoint or until to the end of the program:r,
    single step through the program: s,
    display the content of the CPU internal registers dr and provide a memory dump: dm,
    support (set/clear) for one breakpoint: bs <line>, bc and
    quit the program: q.
    Output shall be written to the screen and (optional) also to a log file that is simple the given assembly-program name (e.g. sum.c), however, instead with an extension *.log (e.g. sum.log).

    The instruction set that shall be supported is defined in the file Instruction Set of the Model CPU on the pages of the lecture Digital Systems on PDF-pages 5-14. This instruction set shall be enhanced by the following assembly commands (shown as examples) for the simulator:

    var .dw <var_value>

    ... reserves space for a variable named var with a value var_value
    Example:
    va .dw 0x1234 ; reserve space for variable va and initialize it with the
    ; hex value 0x1234

    const .equ <const_val>

    ... defines a constant named const that has the value of const_val;
    constants do not reserve memory and are replaced in the code before execution
    (like the #define statment in the C programming language)
    Example:
    ca .equ 5 ; define a constant ca with the decimal value 5
    reg .dr <reg_val>

    ... initializes a register reg:={a, sp, ix, fp} with the value of reg_val
    Example:
    a .dr 0x1010 ; initialize the accu with the hex value 0x1010
    sp .dr 512 ; initialize the stack pointer with the decimal
    ; value 512
    f .df <flag_val>

    ... initializes a flag f:={c, s, z, o} with the value of flag_val
    Example:
    c .df 1 ; set the carry flag
    .org <addr>

    ... defines the start address for the following commands starting at addr;
    every further command is offset by one word (16 bits)
    Example:
    .org 64 ; the following statements are located from address 64 onwards
    .end

    ... defines the end of the code
    Furthermore, symbolic labels (alphanumeric strings starting with an underline character and terminated by a colon and line comments (a line comment starts with a semi-colon shall be supported. All numbers are either decimal or when prefixed by 0x hexadecimal.

    Example program (see the script CPU Progarmmers Model on pages 56-68 for a detailed explanation and discussion):

    ; a simple program that adds two constants using a sub-routine and stores
    ; the result in a variable vc
    ;
    ca .equ 5 ; define a constant ca with value 5
    cb .equ 7 ; define a constant cb with value 7

    .org 128
    vc .dw 0 ; define a variable vc at address 128 (= 0x80) with value 0

    .org 0
    _main:
    lda,c ca ; load constant ca to accu
    push,r a ; push accu to the stack
    lda,c cb ; load constant cb to accu
    push,r a ; push accu to the stack
    call sum ; call sub-routine sum
    sta vc ; vc = accu
    inc,r sp,2 ; deallocate parameter stack
    jmp _end ; jmp to label end
    _sum:
    push,r fp ; save old framepointer
    ldr fp,sp ; mark current frame
    dec,r sp,1 ; space for temp below the fp
    lda,c 0 ; accu = 0
    sta,ri fp,-1 ; temp = accu
    lda,ri fp,2 ; accu = 7 (via stack)
    add,ri fp,3 ; accu = 7 + 5 (via stack)
    sta,ri fp,-1 ; temp = accu
    lda,ri fp,-1 ; accu = temp
    ldr sp,fp ; remove locals from stack
    pop,r fp ; restore fp of caller
    ret ; back to caller
    _end:
    .end

    In a first step the input file must be pre-processed in order to produce the following intermediate representation that is fed as input to the CPU simulator. In particular

    remove all comments,

    replace all constants with their values and remove the definition lines containing the constants,

    map the commands to address locations evaluating and replacing the .org commands (the entire address range is linear covering 2^9 address locations),

    replace the labels within the code with addresses and replace the variable names with their locations that were assigned in the previous step.

    Finally write the initial values of the variables to the according locations.

    After the above steps you will end up with something like in the following listing. 0x000:
    0x002:
    0x004:
    0x006:
    0x008:
    0x010:
    0x012:
    0x014:
    0x016:
    0x018:
    0x020:
    0x022:
    0x024:
    0x026:
    0x028:
    0x030:
    0x032:
    0x034:
    0x036:
    0x038:
    0x040:
    ...
    0x080:
    lda,c 5
    push,r a
    lda,c 7
    push,r a
    call 0x016
    sta 0x080
    inc,r sp,2
    jmp 0x040
    push,r fp
    ldr fp,sp
    dec,r sp,1
    lda,c 0
    sta,ri fp,-1
    lda,ri fp,2
    add,ri fp,3
    sta,ri fp,-1
    lda,ri fp,-1
    ldr sp,fp
    pop,r fp
    ret
    .end
    ...
    0


    It is eventually a good idea to make use of a linked list either after the above steps or already from step 3 onwards. Depending on your implementation the contents of the linked list could be made up by a structure as follows where every structure contains one line:

    struct cpuinst {
    unsigned int breakpoint; // 1 ... breakpoint is active at line; 0 ... breakpoint is inactive at line
    unsigned int addr; // the address, i.e. 0x000 ... 0x1FF
    unsigned char mnem[5]; // the mnemonic of the instruction, e.g. lda ... load accumulator
    unsigned char addrm[3]; // the addressing mode, e.g. ri ... register indirect
    unsigned char op1[20]; // the first operand
    unsigned char op2[20]; // the second operand
    struct cpuinst *pNext; // pointer to the next list element
    };

    The final program structure may now look something similar to the following figure.


    So finally, having pre-processed and prepared the assembly file you are now up to actually start the simulator. After program invocation and having constructed the above list, the program halts before the first instruction. In an endless-loop it will now await directives from the user as shown in the first listing above. For example, a typical user interaction could look like:

    bs 0x04
    r
    dr
    s
    dr
    s
    dr
    dm
    q
    The first user command entered at the prompt (bs 0x04) will set a breakpoint at line 0x10. After having read this line from the user the program will traverse the linked list from the start up to the list holding address number 0x10; there it will set the break field to 1.

    Next the user issued a run command (r); The program will now read list by list by always checking whether a breakpoint in the list is set. When a breakpoint is set the execution of insctructions is halted, otherwise, the command and operands are read and executed as detailed in the Instruction Set of the Model CPU document. In the above example the following steps are performed:

    Check the breakpoint variable on the first list; since it is not set read the command and operands and execute the instruction. Here the command is load the addressing mode is c (constant address) and the operand1 is 5. Execution: accu = 5; flags are left unmodified; IAR (initial calue = 0x00) is incremented by 2
    Read the next list; check the breakpoint variable; since it is not set read the command and operands and execute the instruction. Here the command is push the addressing mode is r (register address) and the operand1 is register a (=accumulator). Execution: the stack pointer (initial value = 0x200) is decremented by 2; the value of the accumulator is stored at the location where the stack pointer now points too (0x1FE); the flags are left unmodified; IAR is incremented by 2 once more, hence, it's value becomes 0x04
    Read the next list; check the breakpoint variable; since the breakpoint is set stop the execution
    The next issued command is dr ... the contents of all relevant regsiters are dumped/output to the screen.

    Afterwards a step instruction s was given ... the next list is fetched the command and operands are read and executed. (Note: when a step command is issued the breakpoint variable is of no relevance/ignored.) Execution: accu = 7; flags are left unmodified; IAR is incremented by 2 -> now 0x06

    The next issued command is dr ... the contents of all relevant regsiters are dumped/output to the screen.

    Afterwards a step instruction s was given ... the next list is fetched the command and operands are read and executed. (Note: when a step command is issued the breakpoint variable is of no relevance/ignored.) Execution: the stack pointer is decremented by 2 -> now 0x1FC; the value of the accumulator is stored at the location where the stack pointer now points too (0x1FC); the flags are left unmodified; IAR is incremented by 2 -> now 0x08

    The next issued command is dr ... the contents of all relevant regsiters are dumped/output to the screen.

    The next issued command is dm ... the contents of the memory is dumped/output to the screen in a compact form.

    The final command q terminates the program.

    When the optional file logging mechanism is implemented all this information (and maybe even more) is written to a log file as well.

    thanks
    hellboyy
    Last edited by hellBOY; 01-13-2009 at 04:24 AM.

  2. #2
    ... kermit's Avatar
    Join Date
    Jan 2003
    Posts
    1,528
    See this for an answer.

  3. #3
    Woof, woof! zacs7's Avatar
    Join Date
    Mar 2007
    Location
    Australia
    Posts
    3,459
    Also that assignment seems very fun... Have you even tried? If so post your attempt, or outline the bits you're stuck on.

  4. #4
    and the hat of wrongness Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    32,484
    > Create a CPU simulator for the model CPU detailed in the lecture Digital Systems.
    Sorry, we all missed that course, so we've no idea what you're talking about.
    It seems you missed it as well.
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.
    I support http://www.ukip.org/ as the first necessary step to a free Europe.

  5. #5
    Jack of many languages Dino's Avatar
    Join Date
    Nov 2007
    Location
    Katy, Texas
    Posts
    2,309
    hellBOY, if you don't know how to start this assignment, you're hosed dude.
    Mac and Windows cross platform programmer. Ruby lover.

    Quote of the Day
    12/20: Mario F.:I never was, am not, and never will be, one to shut up in the face of something I think is fundamentally wrong.

    Amen brother!

Popular pages Recent additions subscribe to a feed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21