pcc/ccom.vax/LOG

There was a bug which caused compiler errors when floating values were
assigned to bit fields.  Some overenthusiastic optimization on my part
led to a float-to-int conversion on the rhs of the assignment being
dropped.  Bit fields are now treated as a special case.  [pcc.vax:
local2.c]

At the instigation of Rob Pike, enums were neutered: they now behave
exactly like ints.  The only traces of Johnson's treatment of enums are
warnings about clashes between one enum type and another enum type in
certain expressions.  This fix was trickier than it looked; it would
have been much simpler to drop ALL warnings about enums, as Rob would
recommend.  [mip: trees.c]

Arthur Olsen pointed out a bug with the evaluation of constant
expressions -- the usual arithmetic conversions are not always
performed.  Rather than follow Arthur's simple suggestion, I decided to
be safe and arranged to use the same conversion code on constants that
we use on variables.  We short-cut the test if the operand(s) are ints,
which is the usual case, so the impact on compile time should be
small.  [mip: trees.c]

Guy Harris noted that chkpun() considered multiply dimensioned arrays
and multiply indirect pointers to be the same thing, which they are
most certainly not.  His fix causes an 'illegal pointer combination'
warning to be emitted for code like:

	char **cpp, c2a[10][20]; cpp = c2a; cpp[5][3] = 'a';

The new code is actually simpler than the old...  [mip: trees.c]

Another irritation of Rob Pike's is fixed -- the old-style assignment
ops have been ifdef'ed out.  No more of those obnoxious 'ambiguous
assignment: assignment op taken' messages!  [mip: scan.c]

Yet another Rob Pike complaint: you couldn't refer directly to the
members of a structure which had been returned by a function.  You may
now utter things like 'f().a' and get away with them.  The illegal form
'(&f())->a' used to work; since this has the same tree representation
as the legal form, an ugly wart was added to the action for '&' which
specifically rules this form out.  To be consistent, a similar
exception was made for expressions of the form '(a = b).c'.  [mip:
cgram.y]

Moved configuration flags from Makefile into macdefs.h and converted
some more trivial routines into macros.  This cleans up the Makefile
considerably and consolidates assembler-dependent flags.  [pcc.vax:
macdefs.h, code.c, order.c, Makefile; mip: onepass.h]

More efficiency hacks: the compiler now does its best to avoid emitting
ANY code after an error is detected.  Previously only code generation
through the code table was suppressed after an error.  This change can
buy up to 25% in speed improvements if the dbx stab flag is enabled.
The latest 'ccom' runs twice as fast as the 4.2 BSD compiler in this
situation...  [pcc.vax:  macdefs.h, local.c, code.c; mip: cgram.y,
scan.c, pftn.c]

For ANSI compatibility, we now accept void expressions in the colon
part of a conditional expression.  Both subexpressions under the colon
operator must be void if one is void.  The overall type of the
conditional expression is void in this case.  [mip: trees.c]

As long as we're doing away with old-fashioned assignment operators, we
might as well terminate old-fashioned initializations too.  [mip: cgram.y]

A fix from James Schoner for bitfield assignments was installed.  The
problem was that the rhs of a bitfield assignment was used as its
value, an overlooked aspect of the several earlier bug fixes for
problems of this variety.  The bug caused

	struct { unsigned a:4, b:3, c:2; } x;
	int i;
	i = x.b = 255;

to store 255 in i instead of 7.  [pcc.vax: table.c, local2.c]

Scanner code was added to handle the System V/ANSI preprocessor
extensions #ident and #pragma.  Currently #ident is ignored.  #pragma
may be used as a substitute for lint-style comment directives; e.g. use
'#pragma LINTLIBRARY' for '/* LINTLIBRARY */'.  The #pragma stuff
requires the hacked-up cpp with ANSI extensions which may eventually be
put into circulation here at Utah.  The #line control from cpp is now
recognized with the same syntax by ccom.  Unknown control lines elicit
a warning.  A small bug is fixed by this new code -- previously #ident
and other unknown controls caused the line control mechanism to get
screwed up, so that bogus dbx stabs were put in the output.  [mip:
scan.c]

There seems to be a loophole in initializations -- apparently it is
legal to initialize a bitfield with a symbolic constant (i.e. the
address of something).  No loader that I know of will handle this!  The
compiler now emits an error when someone tries this trick; it really
can't do any better.  [mip: pftn.c]

Someone complained that all illegal characters were being printed as
octal numbers in the error message.  This was changed so that printable
characters are printed normally, and all funny characters are printed
in C 'char' style.  [mip: scan.c]

Conversion of unsigned constants to floating point values was broken
because the requisite cast in makety() had been commented out!  Argh.
Unsigned comparisons of constants were similarly botched.  [mip: trees.c]

Ray Butterworth made a sensible suggestion that array definitions which
aren't external and allocate no storage should elicit errors.  I
modified his suggestion slightly by moving the test into nidcl(), where
we can be sure that an array isn't being initialized.  I also adopted
his suggestion for a lint warning for arrays with explicit dimensions
that are lost by the rule that converts array types into pointer types
in formal arguments; the warning is contingent on lint's -h flag.
[mip: pftn.c]

The structures for fpn and dpn nodes (floating point constants) were
changed to make them conform in shape to the other nodes.  [mip: ndu.h]

Overenthusiastic SCONV optimization code in optim2() led to functions
not cooperating with certain casts; e.g.

	unsigned char x(); ... y((char)x()) ...

failed to sign-extend the result of x().  [pcc.vax: local2.c]

A bug in outstruct() caused it to check 'stab[-1].name == NULL' for
unnamed structures.  For some reason this didn't break until my recent
lint fixes tweaked the compiler in some subtle way...  [pcc.vax: stab.c]

The makefile was changed to pass C options to lint properly and to drop
the '-a' flag to lint in the 'lintall' entry.  '-a' really ought to
work but unfortunately the arrangement of 'int'-like types in the
compiler is extremely confusing and inconsistent, so I eventually gave
up trying to force the issue.  Sam Leffler's 'rel.c' for release
information was also added.  [pcc.vax: Makefile, rel.c]

I fixed defid() so that it now insists that all argument type
declarations must refer to names in the argument list.  Previously you
could get away with:

	int a;
	x()
		int a;
	{ ... }

Use of 'a' in the body of x() would elicit the immortal error message
'warning: bad arg temp'.  [mip: pftn.c]

For some reason, mainp2() in the two-pass version of the compiler had a
switch statement with two 'default' cases.  I zapped the obvious one.
[mip: reader.c]

Botched initializations sometimes left the declarations code in a funny
state, so a fixinit() routine was invented to aid error recovery.  For
example, the following illegal program forced a core dump:

	char m[] = ;
	x() {
		y("splat");
	}

The compiler tried to read "splat" into m[] and died horribly.  [mip:
cgram.y, pftn.c]

The compiler now warns 'can't take size of function' when asked to do
something amazing like '... void f(); ... if (f[10]) ...'.  Previously
it produced a compiler error instead.  [mip: pftn.c]

If a program tried to access a value below the argument list on the
stack using the clever tactic of manipulating the address of an
argument, it drew a warning 'bad arg temp'.  For the sake of these
clever programs, the warning has been suppressed.  [pcc.vax: local2.c]

The assembler would sometimes print 'Branch too long: try -J flag' even
when you used the -J flag and when there was no reason for it to be
making long branches.  This was due to a bug in jxxxfix() which caused
tests for explodable branch instructions to terminate early in later
phases of the topological sort, because the loop termination code
didn't take into account the fact that not all code addresses are
updated by jxxxbump().  The fix is to match the pointer to the data
structure for the code in the sorted table rather than check for its
generated address.  [as: asjxxx.c]

The peephole optimizer normally compares instructions for equality
based on their instruction type and their operands.  Unfortunately
several instructions are too complex for c2 to handle and are given an
instruction type of 0; thus all such instructions compared equal.  The
equop() routine was changed to test the names of these '0' type
instructions for equality.  [c2: c21.c]

The compiler sometimes botched computations into stack temporaries by
treating expressions like '-40(fp)[r1]' as permissible temporaries.  I
rewrote the shtemp() routine to make it explicit that the 'stack
temporary' goal in code generation means precisely that the final
expression must not contain any references to temporary registers (like
r1).  I had to add a couple templates to the code table to push
exceedingly complex OREG expressions onto the stack when this goal is
attempted.  [pcc.vax: local2.c, table.c]

A bug sometimes caused a redeclaration of an array in an inner scope to
affect the outer array when the outer array was incompletely specified
(by leaving out the most significant dimension).  For example:

	extern int a[];
	x(){ int a[10]; }
	int a[20];

This code would elicit the error 'foo.c, line 3: redeclaration of a'.
The routine defid() is used to enter new definitions; for some reason
scope problems are not resolved in defid() until much other code has
been executed, including code that deals with filling out array sizes.
The change makes defid() notice inner scopes with auto and register
declarations earlier than usual.  [mip: pftn.c]

Case expressions are explicitly restricted to contain only int constants,
char constants and sizeof expressions (C Reference Manual section 15).
Previously the compiler didn't test for expressions like '(int) &foo[10]'
and thus it would generate some rather bogus code.  Expressions which
resolve to names now elicit the same 'non-constant case expression'
warning which you receive for variables.  [mip: cgram.y]

The value of an assignment to an unsigned bitfield was signed through
an oversight in the code table.  [pcc.vax: table.c]

From Sam Kendall, a fix to prevent structs, unions, floats, doubles
and void from being cast to pointer types.  [mip: trees.c]

Some relict code in moditype() was causing void functions not to be
converted into pointers in some situations.  [mip: trees.c]

A minor optimization -- when the lhs of a simple assignment op (&=, |=,
^=, +-, -=) is smaller than int size, we can sometimes pun the rhs and
avoid promoting the lhs to int, performing the operation in int width
and converting from int back to the lhs type.  For example:

	register char *ap, *bp;
	*ap++ |= *bp << 1;

This used to require 7 instructions, but now needs only 3.  [pcc.vax:
table.c]

At some point I added code to conval() to balance types before
performing constant folding...  While hacking on the tahoe compiler, I
decided that this code was too complex and replaced it with equivalent
code that's shorter and easier to understand.  [mip: trees.c]

Lines containing multiple statements were broken up for the sake of
tracing with the source debugger in tcheck() and talloc().  [mip:
common.c]

I discovered that the C compiler called urem() in three different
places with a constant divisor...  In my subsequent rampage I hacked
the compiler to generate inline code for all unsigned division and
modulus operations with constant divisors.  The largest inline
expansion should use only 5 instructions, with most using just 3 or 4.
The changes touched several files but really weren't very messy.
[mip:  pass1.h, match.c; pcc.vax: local2.c, order.c, table.c]

A lot of new code was added to handle a really simple problem:

	unsigned char uc = 255;
	if (uc == -1) ...

This incorrectly tested true, because the compiler generated a test
that looked only at the low order byte of the constant.  Not only that,
but the compiler didn't realize that this test could be short-
circuited, since -1 is equal to 4294967295 unsigned and is hence out of
the range of an unsigned char.  Rather than add lots of cruft to the
code table, I shoved it into optim2() -- the compiler now picks up all
the absurd cases where a constant is out of the range of precision of
a variable it's tested against.  To avoid having to write lots of code
templates to handle unbalanced unsigned/signed expressions, I forced
tymatch() to take notice of unbalanced expressions and promote the
signed operand to unsigned (except with assignment operators, sigh).
This change in turned required tweaks in autoincr() and in the code
table to get code quality back.  I hope I can come up with a better way
to do this...  [mip: trees.c; pcc.vax: local2.c, order.c, table.c]

The value of TNULL was changed from 'pointer to undef' to 'pointer to
member of enum' so that 'void *' can be a real type.  TNULL is used to
tag unused symbol table slots.  [mip: manifest.h]

A bug in clearst() led to problems with 'schain botch' errors.  When a
hash collision occurs, a symbol is (linearly) rehashed; if the symbol
which forced the rehash is deleted, the relook() loop in clearst() will
cause another symbol with the same hash code to move up and replace the
deleted symbol.  Torek's 'schain' hack for speedy identification of
symbols at the same block level will get screwed up by this operation
since it relies on a linked list of table entries -- moving an entry
garbles the list.  How did this code ever work before?  [mip: pftn.c]

Changed putins() in ascode.c in the assembler to permit 0(pc) as a
write operand...  Previously the assembler automatically optimized
this to (pc), which is an illegal operand.  [as.vax: ascode.c]

The complement of an unsigned char or unsigned short value should have
its high bits set, since the 'usual arithmetic conversions' widen these
small integers 'before' the operation.  [pcc.vax: table.c]

A minor code improvement in ccom led to problems in c2 -- c2 was able
to optimize sequences like 'cvtbl -4(fp),r0; bicl2 $-256,r0' but not
the (shorter and faster) 'cvtbl -4(fp),r0; movzbl r0,r0'.  A change in
bflow() causes redundant conversions to be noted and removed, restoring
code quality.  [c2: c21.c]

A typo in the 'bitsize' array definition resulted in an unterminated
comment which screwed up the bit sizes for several types.  I only
noticed this because I ran the source off with vgrind and the error
was exposed by comment highlighting...  [c2: c21.c]

An earlier change to conval() caused LONG and ULONG types to be hacked
into INT and UNSIGNED; this was fine for the (VAX) compiler, but led
to inconsistencies with lint.  [mip: trees.c]

When a syntax error occurs, the parser throws away tokens until it can
enter a known state.  If a string or character constant delimiter is
tossed, the parser will try to interpret the contents of the constant
as code and can get very confused.  A hack was added to yylex() to
detect this situation -- basically, if a delimiter is seen but the
string or character constant has not been processed by lxstr() at the
next call to yylex(), yylex() will call lxstr() itself and dispose of
the rest of the constant.  [mip: scan.c]

Following a suggestion by Arthur Olsen, the production for 'switch' was
modified to complain about constant switch expressions with 'lint -h'.
[mip: cgram.y]

Another Arthur Olsen bug report pointed out a problem with increment
operations that don't match a code template...  Two attempts at
rewriting the increment are made: the first tries to turn the lvalue
operand into an OREG, and the second applies a tree transformation to
convert 'x++' into '(x += sizeof x) - sizeof x'.  A mistake in the
routine setincr() caused the lvalue operand in its entirety to be
generated into a register instead of just the lvalue operand's address,
producing something like 'r0 = x, (r0 += sizeof x) - sizeof x' instead
of 'r0 = &x, (*r0 += sizeof x) - sizeof x'.  [pcc.vax: order.c]

Better code for floating post-increment and -decrement can be generated
with a simple change to the code table and to zzzcode() so that the
same hack for ordinary post-increment will work for floating point too.
[pcc.vax: local2.c, table.c]

I added Arthur Olsen's massive lint fixes for typechecking printf().
It sure would be nice if there were a way to specify new printf-like
commands at execute time, perhaps through lint directives embedded in
include files.  [lint: lint.c]

Arthur's warning about superfluous backslashes was added to lxstr().
Rather than adding Arthur's (expensive) code for warning about the
use of '$', I simply made it illegal (unless 'VMS' is defined).  I
also took the opportunity to remove '`' gcos BCD constants.  I made
a slight alteration to yylex() to cause it to eat unknown characters
rather than punt, since this seemed more useful.  [mip: scan.c]

Lint would sometimes print a bogus 'i set but not used' warning in
situations like this:

	static int i;
	static int *ip = &i;

	i = 1;
	return *ip;

If you moved the initialization out of the declaration, the warning
disappeared.  I installed Arthur's hack for forcing lint to examine
initializations.  This causes lint to treat initializations of auto,
register and static variables as 'uses' and to ignore sizeof
expressions as 'uses'.  Also, '&i' in a static or external
initialization is now a 'set' and a 'use' of 'i'.  [lint: lint.c; mip:
cgram.y, pftn.c]

VARARGS0 is now correctly treated differently from plain VARARGS.
I don't remember who originally noticed this...  [lint: lint.c,
lpass2.c]

The register allocation code failed to 'share' register pairs.  I don't
know why this escaped notice for this long...  I added a bit in the
'busy' array to keep track of pairs and modified the code in usable()
to notice pairs and try to 'share' them.  Some other code which treated
the values of busy[] elements as arithmetic values had to be changed;
there is now a macro which performs the proper test.  [mip: allo.c,
match.c, pass2.h]

Some extensive code tweaking...  (1) If order() is called on to rewrite
a UNARY MUL node and that node has a usable index expression, we now
try to rewrite the base into a register so that oreg2() will produce a
doubly-indexed OREG.  This is usually an impressive space saving.  (2)
Instead of laboriously copying a constant 0.0 in data space to clear a
double or a float, we issue the proper 'clrd' or 'clrf'.  This is done
by a trick using an alternate prtdcon() routine; I'm not sure who
invented it.  I guess I'm still not prepared to hack in support for
floating literals and immediate constants.  (3) The conversion code now
handles stack pushes directly, which often saves a spill to register.
With very little adjustment, this also buys us optimally small pushes
of constants.  (4) Pointer comparisons are now unsigned; I'm not sure
what this really buys us, but I added it anyway.  (5) AND tests against
constants are 'small' if both the constant and the other operand are
also 'small'.  (6) base() now recognizes that NAME nodes can be used in
pc relative deferred indexed addressing, which is much more compact
than the equivalent code to compute the address into a register and
indirect through it.  (7) The optimization code for ANDing with a
constant now tries to produce a positive mask when small types are used
so that literal operands are possible; a side effect is that the code
is more readable.  (8) UCHAR/USHORT to FLOAT/DOUBLE conversions take an
extra step through INT type to avoid the overhead of an UNSIGNED to
FLOAT/DOUBLE conversion.  (9) If a logical operator sits above a pair
of FLOAT to DOUBLE conversions, the conversions are deleted.  (10) Vast
numbers of redundant or useless templates were deleted from the code
table.  (11) Conversions to FLOAT in double-only arithmetic now go to
the trouble of clipping off excess precision from INT and DOUBLE
operands.  (12) DOUBLE to DOUBLE conversions introduced by reclaim()
are now silently deleted in the table.  (13) A few 'movd's were turned
into 'movq's -- more work needs to be done to make this consistent.
[mip: reader.c; pcc.vax: macdefs.h, local.c, local2.c, table.c]

A bug which caused assignment op expressions with an unsigned char or
unsigned short lhs and a floating rhs to treat the lhs as signed was
fixed.  Some conversion-related stuff which used to be done in the
table is now done in sconv() so that it's easier to handle and so that
zzzcode() and its descendants can more safely perform conversions by
calling zzzcode(p, 'A').  [pcc.vax: local2.c, table.c]

The code for setting the type of a floating point constant was bogus.
A floating constant was float if it fit in a float without loss of
precision, otherwise it was double.  This caused silliness like
unexpectedly losing low order bits of integers in mixed floating and
integral expressions.  The fix was to adopt the ANSI proposal that all
floating constants are type double unless they bear an 'f' or 'F'
suffix, in which case they are type float.  (Note that a cast to float
has the same effect as a 'f' suffix and is just as efficient, but I
conceded to the evident popularity of the 'f' suffix...)  [mip: scan.c;
pcc.vax: local.c]

The ASG OPSIMP templates that produce byte and word instructions for
byte and word destinations weren't being activated very often because
the constant operands weren't normalized.  I added code to optim2() to
appropriately reduce the range of constant operands of ASG OPSIMP
operators and sign-extend.  This blows away many useless conversions to
and from int.  [pcc.vax: local2.c]

The template for assignment ops with unsigned char/short lhs and
floating rhs indicated register sharing for the wrong operand...
[pcc.vax: table.c]

The new template that handled OREG for INTEMP failed to take into
account the size variation in OREG objects.  [pcc.vax: table.c]

The offstar() routine tries to tweak UNARY MUL trees so that they can
be handled most effectively by VAX addressing modes.  The code for
identifying index expressions was adjusted so that more indexed
addressing modes can be produced.  [pcc.vax: order.c]

Bogus error messages were being emitted for certain initializations
following an earlier legitimate error.  It turns out that the
optimization to prevent initialization code from being emitted after
errors was preventing the initializer offset counter from being
updated, and when this occurs, the initialization code screws up -- for
example, string constants appear to be zero length.  The initialization
code now always updates the offset even if errors have been detected,
although code generation is still suppressed.  [pcc.vax: local.c]

An assignment to a bitfield in an indexed int-width structure led to
code generation failure due to an indexed OREG child of FLD.  This is
taboo because the VAX field instructions have byte-size side effects,
and code in clocal() arranged for indexed structs to have int width.
I changed clocal() to use byte width instead and it appears to work now
(and even uses indexed byte addressing correctly).  [pcc.vax: local.c]

For some reason the unsigned-to-floating conversion code has always
been long and complex when it could be short and simple.  I used the
simple code in the Tahoe compiler but didn't think to put it in the VAX
compiler until prodded by Robert Firth...  [pcc.vax: local2.c]

John Gilmore noticed that the ! operator didn't work with floating
constants; this was pretty easy to fix.  [mip: trees.c]

For some reason, opact() put left and right shifts through tymatch().
The type balancing of tymatch() is wrong for shifts -- the type of the
shift depends only on the left operand, while the right operand is
converted to int.  We now use the shift special case in buildtree() to
fix the type.  [mip: trees.c]

Following ANSI (for once) we eliminate warnings for pointer conversions
involving void *.  [mip: trees.c]

There were at least a couple bugs in c2 with code that converts 'ashl
$2,rA,rB; movab _x[rB],rC' into 'moval _x[rB],rC'; one caused the type
to be wrong ('movab' for 'moval'), one caused neighboring instructions
to get deleted.  [c2.vax: c21.c]

A branch to a redundant test sometimes resulted in c2's deleting the
label too, even if the label itself was not redundant.  [c2.vax: c21.c]