WISC C-- Compiler

This is a C-- compiler that targets MIPS and WISC assembly language. C-- is C with some stuff removed. C-- supports the types int and bool (no floats or chars).

• goto
• union
• variables can't be initialized when declaring them. this is NOT ok... int x = 5;
• multiple variables declared on a single line. this is NOT ok... int x, y;
• function pointers.
• ++ and -- operators.
• the ?: if else construct.
• linking between multiple files.
• command line params
• variable argument functions
• multiple statements in a for loop expression. this is NOT ok... for (i = 0, j = 3; ...)
• break and continue statements
• switch/case statements
• multi-dimensional arrays (use an array of pointers)
• typedef
• bitwise operations
• all if, while, and for statements must have {}.

Note: += -= *= /= are all implemented but do not have the correct semantics. a += b just expands into a = a + b which is fine if a and b are simple expressions, but they are different from C when a involves a function like "*func() += b;" func() in this case will be evaluated twice.

Everything else should be valid C-- (including pointers to ints and bool) ex: this is a valid function

int **func(int *a, int **b, int size) {
  int i;
  i = 0;
  while (i < size) {
    b[i] = NULL;
    i = i + 1;
  }
  return b;
}
int **func2(int *a, int **b) {
  while (*b != NULL) {
    *b = a + 14;
    b = b + 1;
  }
  return b;
}

Allocating data on the heap. The C-- compiler generates a function "void *sbrk(int length);" which will return a pointer to a segment of memory length long. For MIPS, it gets space through the sbrk system call. For WISC, it just uses the space directly after all the code. A memory manager that maintains a list of free blocks can be implemented on top of this, providing the standard malloc() and free().

cout << "This is cool\n";
cin >> x;
cout << x + 2;
cin >> y[15];

These are not streams like in C++, the format must be "cout << some expression" or "cin >> some variable". When exporting to WISC, the read statements are just ignored and write statements use the wrint and wrch instructions.

The WISC architecture implements multiplication and division by exporting two functions (in wisc.java) that carry out the operation. They are really slow! They take the numbers to multiply or divide in $v0 and $v1 and return the result in $6. divide returns the result in $6 and the remainder in $t0. (used by the % modulo operator)

Test Programs

• sortSmall.C: Sorts a list of 10 integers.
• sort.C: Sorts a list of 500 integers. You can easily reduce the number of integers to sort and time will go down. This really stress tests the memory and cache, because after this the cache should be completly full. The numbers to sort are randomly generated by a perl script sort.pl and then appended onto the mem file.
• testComp.C: A bunch of stuff to test the compiler. Uses the output extension to WISC to write the results of the test.
• maze.C: Generates a random maze and prints it on the output.

Running the compiler

To run the compiler, you can either download the cmm.jar file or if you are working in the CS computer labs you can add the following line to .cshrc.local

setenv CLASSPATH ".:/s/java/jre/lib/rt.jar:/u/l/e/lenz/public/cmm.jar"

% java cmm <input.C> <output.s>
% wiscas <output.s>
% wisc-emulator <output.mem>

% java cmm --mips <input.C> <output.s>
% spim -file <output.s>

Compiling and modifing the compiler

To compile the compiler you will need Java CUP and JLex installed in the CLASSPATH. I suggest you include the runtime classes in the cmm.jar file. Then Java CUP and JLex don't need to be on the CLASSPATH to run the compiler.

• c.cup and c.jlex contain the parsing and lexing rules.
• Sym.java and SymTab.java contain the symbol table entries and the symbol table
• ast.java expressions.java statements.java contain the abstract syntax tree
• cmm.java is the main class
• wisc.java contains the multiply and divide functions which get appended.
• Codegen.java contains a bunch of useful code generation functions
• Errors.java and IO.java contain some helper classes

To make changes to the exported WISC assembly language, you will need to look in ast.java, expressions.java, statements.java and Codegen.java. There is a boolean stored in the Codegen class which gets set based on the command line param, so in ast.java there is code that looks like

if (Codegen.Wisc) {
  /* generate wisc assembly */
  Codegen.generate(..);
  ..
} else {
  /* generate MIPS assembly */
  Codegen.generate(..);
}

A lot of the exported code is the same so no checking is even done. Expressions are evaluated with a simple stack approach. Arguments are pushed onto the stack and operators pop them off. Branching uses a Control-Flow Code approach. There is a small optimization: when a push is followed immediatly by a pop, both are removed and a move instruction is added if the registers are different. The stack starts at FFFF and grows downward. The AR for each function contains, from top to bottom: params, return address, control link, local vars.