CS/CE 218 Lab 6					9 October 1991

The report for this lab is due Monday, 14 October 1991.
The exercises contained in this lab are intended to help familiarize you
with the compilation process the GNU C compiler (gcc).
C compilers, including gcc, do a preprocessing step to generate
code without #include or #define, compile that code to assembly language,
assemble that into an object file, which may be linked into an executable.

(The main documentation for gcc is in the manual page (execute ``man gcc'');
documentation can also be found using info in emacs (C-h i m gcc).
You might also look in Chapter 1 of "The C Programming Langauge (2nd ed)"
or chapter 14 of "Introducing Unix System V" for more help.)


To start put the following code in a file logic_ops.c.
(In emacs you can edit logic_ops.c, and yank the following;
or if you'd rather, just copy the file $PUB/lab-data/lab6/logic-ops.c)

#include <stdio.h>

int getline(char s[], const int lim)
     /* effect: read a line into s, return it's length */
{
  int c, i;

  for (i=0; i<lim-1 && (c=getchar()) != '\n' && c != EOF; ++i)
    s[i] = c;
  if (c == '\n') {
    s[i] = c;
    ++i;
  }
  s[i] = '\0';
  return i;
}

With the -S option, gcc produces assembly language code.
Look at the output of
	gcc -S logic_ops.c
(it will be in the file logic_ops.s).
Save the result of ``gcc -S logic_ops.c'' in a file ``unoptimized.s''
(hint: how do you rename a file in Unix?).

With the -O option, gcc ``optimizes'' the code it produces.
Look at the output of
	gcc -O -S logic_ops.c
Save the result of ``gcc -O -S logic_ops.c'' in a file ``optimized.s''

1. (3 points) What shell command(s) will tell you whether the code in
   optimized.s has fewer instructions than the code in unoptimized.s?
   Which one is shorter?


2. (3 points) What shell command(s) will show you the differences between
   the optimized code and the unoptimized code?



3. (10 points) Copy the file logic_ops.c to the file ``no_logic_ops.c''.
   Rewrite the for loop in the file no_logic_ops.c, so that it does *not*
   use logical operators; that is, take out the uses of && and write a
   function that does the same thing, without using && or ||.  (Be sure
   to get all the syntax errors out of your function!)



That's it, you're all done.  The rest of this file contains extra credit
problems only.


4. (extra credit only) Are there any differences between the assembly code
   for no_logic_ops.c and logic_ops.c?  Does using optimization eliminate
   the differences?


5. (extra credit only) Write a main program that uses getline to copy
   lines of less than 100 characters from standard input to standard output.


6. (extra credit only) Look at the output of
	gcc -E logic_ops.c
   How does it change if you leave the #define line out of the program?