3582 lines
140 KiB
Plaintext
3582 lines
140 KiB
Plaintext
Sun Dec 31 10:47:51 1989 (tiemann at calvin)
|
|
|
|
* cplus-cvt.c (build_up_reference): Take multiple inheritance into
|
|
account in all (instead of just some) cases. Take virtual
|
|
baseclasses into account in all (instead of no) cases.
|
|
|
|
* cplus-init.c (build_vbase_delete): Convert ADDR before calling
|
|
destructr. Otherwise privately derived baseclasses will give
|
|
problems.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): Distinguish case where
|
|
initializer list fails because virtual baseclass lacks default
|
|
initializer and other bad argument lists.
|
|
|
|
Sat Dec 30 13:09:43 1989 (tiemann at calvin)
|
|
|
|
* cplus-tree.h (lang_type): Added bit for MARKED6. Used to use
|
|
MARKED3 to mean `base class initialized', but that conflicts with
|
|
use meaning `virtual baseclass processed' in cplus-search.c.
|
|
* cplus-init.c (finish_base_init): Use _MARKED6 instead of
|
|
_MARKED3 to indicate a baseclass has been initialized.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): If TYPE_HAS_CONSTRUCTOR(TYPE)
|
|
but no constructor takes the initializer, and there is no X(X&)
|
|
constructor, generate code for X(X&) constructor by hand.
|
|
|
|
* cplus-typeck.c (build_modify_expr_1): Substantially simplified
|
|
using assumption that LHS and RHS are type-compatible as a
|
|
consequence of being elements of isomorphic structures.
|
|
|
|
* cplus-init.c (expand_aggr_init): If EXP is initialized from
|
|
an object of its same type, and EXP does not have an X(X&)
|
|
constructor, have build_modify_expr do the work.
|
|
|
|
Fri Dec 29 00:29:45 1989 (tiemann at calvin)
|
|
|
|
* cplus-class.c (finish_struct): Don't build default functions by
|
|
default. Instead, rely on compiler doing the Right Thing when
|
|
handling INIT_EXPR and MODIFY_EXPR.
|
|
|
|
* cplus-typeck.c (build_modify_expr): Don't copy virtual function
|
|
table fields or virtual baseclass fields when performing
|
|
memberwise copying.
|
|
Instead, split `build_modify_expr' into two functions, a recursive
|
|
form `build_modify_expr_1' which doesn't do any copying for
|
|
virtual baseclasses, and a non-recursive form `build_modify_expr',
|
|
which does handle these at top level.
|
|
|
|
Thu Dec 28 12:37:37 1989 (tiemann at calvin)
|
|
|
|
* cplus-decl.c (build_default_constructor): Typo--used
|
|
DECL_VIRTUAL_P (...) when VFIELD_NAME_P (DECL_NAME (...)) was
|
|
meant. Also, take into account fact that second arg might be "in
|
|
charge" arg.
|
|
|
|
* cplus-class.c (finish_base_struct): Move setting of
|
|
TYPE_USES_VIRTUAL_BASECLASSES from here...
|
|
* cplus-decl.c (xref_tag): ...to here. Needed because
|
|
constructors for virtual baseclasses now need new type signatures.
|
|
|
|
* cplus-decl2.c (grokclassfn): Rewrote code that inserts
|
|
parameters so that SOS will work with virtual baseclasses.
|
|
@@ But rest of SOS code must be changed to deal with this.
|
|
|
|
* cplus-init.c (expand_aggr_vbase_init): Changed interface. Last
|
|
arg is no longer FUNCTION_DECL, rather, it is the list of
|
|
initializations that the constructor must perform (if in charge).
|
|
All virtual baseclasses, whether they need constructors or not,
|
|
will be initialized one way or another.
|
|
|
|
* cplus-decl.c (finish_function): Don't do special things for
|
|
constructors with virtual baseclasses. Leave that up to
|
|
`finish_base_init'.
|
|
* cplus-init.c (finish_stmt): Same change.
|
|
|
|
* cplus-init.c (finish_base_init): Test "in charge" variable and
|
|
conditionally do all virtual baseclass initialization.
|
|
|
|
* cplus-class.c (build_method_call): New flag LOOKUP_HAS_IN_CHARGE
|
|
which means that parameter list comes with the "in charge"
|
|
parameter already set up. If the call is to a constructor, and
|
|
this flag is not set, then say we are "in charge" iff constructor
|
|
called is for new object.
|
|
* cplus-init.c (expand_aggr_init_1): Add "in charge" parameter
|
|
when appropriate, and set FLAGS in those cases.
|
|
|
|
* cplus-method.c (fndecl_as_string): Don't print "in charge"
|
|
variable when formatting constructors for objects with virtual
|
|
baseclasses.
|
|
|
|
* cplus-tree.h (lang_decl): Add bit for constructors which build
|
|
objects with virtual baseclasses. These constructors take a new
|
|
extra argument after the `this' pointer that says whether they are
|
|
"in charge" of initializing virtual baseclass things or not.
|
|
* cplus-decl2.c (grokclassfn): Set DECL_CONSTRUCTOR_WITH_VBASE_P
|
|
bit when appropriate. Also, add extra parameter in that case.
|
|
* All GNU C++ files: Change name of AUTO_DELETE_IDENTIFIER to
|
|
IN_CHARGE_IDENTIFIER, since that is the correct generalization of
|
|
its function, and thus allows the same identifier to be used in
|
|
constructors and destructors.
|
|
|
|
Thu Dec 21 12:58:05 1989 Michael Tiemann (tiemann at hudson)
|
|
|
|
* cplus-init.c (expand_aggr_init): If initializing from a GNU C
|
|
CONSTRUCTOR, consider the elts in the constructor as parameters to
|
|
an implicit GNU C++ constructor.
|
|
|
|
Wed Dec 20 10:45:46 1989 Michael Tiemann (tiemann at hudson)
|
|
|
|
* cplus-decl.c (duplicate_decls): Don't know why I turned off
|
|
propagation of DECL_IN_AGGR_P bit, but it needs to be
|
|
on--otherwise we cannot catch duplicate method declarations in
|
|
class scope. Was it turned off (erroneously) for efficiency
|
|
reasons?
|
|
|
|
* cplus-class.c (convert_harshness): Don't see two functions
|
|
needing user-defined type conversions as ambiguous is one comes
|
|
from immediate class, when the other comes from a base class.
|
|
|
|
* cplus-decl.c (grokdeclarator): Don't permit storage class
|
|
specifiers in parameter declarations.
|
|
|
|
* cplus-typeck.c (mark_addressable): Say we're sorry if named
|
|
return value much change from register to memory. Also, since
|
|
TREE_ADDRESSABLE is checked at top, no need to recheck in various
|
|
other parts.
|
|
* cplus-cvt.c (build_up_reference): Same change.
|
|
|
|
* stmt.c (expand_function_start): If function value is in a
|
|
register, set TREE_REGDECL of the DECL_RESULT.
|
|
|
|
* cplus-class.c (convert_harshness): Conversion of enum to int
|
|
costs an extra penalty. Also, don't permit one kind of enum to
|
|
convert to another.
|
|
|
|
* cplus-search.c (dfs_pushdecls): Only set TREE_USED to zero for
|
|
FIELD_DECLS. If we zero it out for e.g. VAR_DECLs, they won't get
|
|
written out at end of file.
|
|
|
|
Tue Dec 19 17:19:31 1989 Michael Tiemann (tiemann at hudson)
|
|
|
|
* cplus-decl.c (finish_decl): If we are at top level and
|
|
allocation is temporary, switch to permanent allocation before
|
|
calling `grok_reference_init'. Also, initialization of references
|
|
was losing when initializer was a constructor.
|
|
@@ Problem that must be better solved: The compiler was confused
|
|
about what NEW_EXPR meant--when it when looking for temp space for
|
|
the reference, it was grabbing space from the file-level
|
|
initialization function, not from static space. What's needed is
|
|
objects which really know how to get the kind of space they are
|
|
looking for when they are really expanded.
|
|
|
|
* cplus-type2.c (build_functional_cast): Check that type is
|
|
defined before testing various constructor bits.
|
|
|
|
Thu Dec 14 15:14:12 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-tree.c (make_deep_copy,copy_to_permanent): New functions.
|
|
* cplus-init.c (build_new): Dec 12 change was wrong. Instead,
|
|
call copy_to_permanent if we need to stash away the initializer.
|
|
|
|
Tue Dec 12 01:16:31 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-init.c (build_new): Check that INIT is not NULL_TREE
|
|
before checking its permanence.
|
|
|
|
* cplus-decl.c (decls_match): If TREE_TYPE (NEWDECL) is
|
|
ERROR_MARK_NODE, don't call comptypes.
|
|
|
|
* cplus-decl2.c (grokclassfn): Parameters for constructors with
|
|
virtual baseclasses must be build on permanent_obstack.
|
|
|
|
* cplus-parse.y (member_init): If using old-style member
|
|
initialization for base class, remember to move allocation to the
|
|
permaent_obstack before reading the initializer.
|
|
|
|
* cplus-class.c (build_method_call): If global member function is
|
|
good, record that fact in BEST. That way our early-out for member
|
|
functions won't accidently call an inferior member function.
|
|
|
|
* cplus-decl.c (grokdeclarator): If TREE_CODE (decl) ==
|
|
ERROR_MARK, then silently continue processing, rather than
|
|
aborting compilation.
|
|
|
|
* cplus-parse.y (except_stmts): Call `expand_start_catch' and
|
|
`expand_end_catch' instead of `expand_exit_except' when expanding
|
|
default catch clause. Otherwise, we scream out to the next
|
|
handler, not to the point after the handler.
|
|
|
|
* cplus-class.c (build_overload_call): continue statement missing
|
|
in TYPE_DECL case.
|
|
|
|
Sat Dec 9 23:27:56 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-decl.c (xref_tag): Mark REF in addition to all its
|
|
basetypes so we can protect against the user declaring recursive
|
|
types by accident. Also fixed Braino in testing value of I after
|
|
the BINFO loop.
|
|
|
|
Thu Dec 7 16:37:28 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-search.c (dfs_record_inheritance): Check that MI_SIZE is
|
|
nonzero before entering loop which uses it as stride.
|
|
|
|
* cplus-typeck.c (build_component_ref_2): Make subroutine of code
|
|
which builds the final COMPONENT_REF structure because it must be
|
|
recursive in the case we have a field from a base class of a
|
|
virtual base class.
|
|
|
|
Wed Dec 6 08:05:59 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c (build_scoped_method_call): Dec 2 introduced a bug
|
|
by attempting to optimize tree node allocation. Fixed by always
|
|
converting EXP.
|
|
|
|
* cplus-decl.c (grokdeclarator): If TYPE becomes ERROR_MARK_NODE,
|
|
and we are chasing down the declarator, must chase to TREE_OPERAND
|
|
(DECLARATOR, 1) if TREE_CODE (DECLARATOR) is SCOPE_REF.
|
|
|
|
* cplus-class.c (finish_struct): Change criterion for building
|
|
init list from != CONST_DECL to == FIELD_DECL. Also, don't count
|
|
a class as needing constructing or needing constructor based on
|
|
static members.
|
|
|
|
* cplus-init.c (expand_vec_init): Call itself recursively with
|
|
FROM_ARRAY nonzero if TREE_TYPE (init) is same as TREE_TYPE (exp).
|
|
Also, if coming FROM_ARRAY, only call `expand_aggr_init' if there
|
|
is a constructor to call. Otherwise, call `expand_assignment'.
|
|
|
|
* cplus-class.c (finish_struct): Can't have a default constructor
|
|
if the class has reference types without default initial values.
|
|
|
|
* cplus-tree.h (TYPE_RAISES_EXCEPTIONS): Use TYPE_NAME instead of
|
|
(tree) TYPE_LANG_SPECIFIC.
|
|
* cplus-decl.c (duplicate_decls): Now TYPE_LANG_SPECIFIC implies
|
|
IS_AGGR_TYPE always.
|
|
|
|
* cplus-init.c (build_default_constructor): Don't build
|
|
initializer for default members.
|
|
|
|
* cplus-class.c (finish_struct): If FUNCTION_DECL has
|
|
IDENTIFIER_ERROR_LOCUS set, then don't keep the function in the
|
|
class. It is evil.
|
|
|
|
* cplus-init.c (expand_member_init): Don't permit initialization
|
|
of member from base class--unless baseclass is virtual and has no
|
|
constructor.
|
|
* cplus-init.c (member_init_ok_or_else): New function
|
|
encapsulating this and other checks for validity of member
|
|
initialization.
|
|
|
|
* cplus-type2.c (build_functional_cast): Try going through type
|
|
conversion function if no constructors apply.
|
|
|
|
* cplus-typeck.c (c_expand_return): When returning a named return
|
|
value, call `use_variable' on the result, in case it is in a
|
|
register.
|
|
|
|
* cplus-class.c (compute_conversion_costs): Don't warn about
|
|
contravariance violations (or other problems) as a result of
|
|
calling `comp_target_types' (via call to `instantiate_type').
|
|
|
|
* cplus-init.c (expand_aggr_init): Check that INIT is nonzero
|
|
before accessing its TREE_TYPE.
|
|
|
|
Tue Dec 5 00:13:33 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* integrate.c (copy_rtx_and_substitute): If we folded something
|
|
completely into a constant, don't try to make it a legitimate
|
|
memory reference out of it.
|
|
|
|
* cplus-class.c (propagate_basetype_offsets): Forgot to set
|
|
ASSOC_TYPE (ASSSOC) when building the new basetype.
|
|
|
|
* cplus-init.c (expand_aggr_init): When initializing const array,
|
|
turn off const bits during initialization. Otherwise constructor
|
|
can't be called (since it is calling from const object to
|
|
non-const member function).
|
|
|
|
* cplus-method.c (build_overload_name): Set PARMTYPE to
|
|
TYPE_MAIN_VARIANT (PARMTYPE) after extracting interesting bits.
|
|
|
|
Mon Dec 4 04:56:08 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-decl.c (finish_decl): wrt Nov 14 change, only change
|
|
DECL_NAME of TTYPE if DECL is not a FUNCTION_DECL. It screws up
|
|
consing up of default functions.
|
|
* cplus-decl.c (grokdeclarator): When replacing anonymous aggr
|
|
names with reasonable aggr names, change the names of any default
|
|
constructors and/or destructors.
|
|
|
|
* cplus-tree.h (type_flags): Added bits for
|
|
TREE_GETS_CONST_{ASSIGN,INIT}_REF.
|
|
* cplus-decl.c (grok_{ctor,op}_properties): Set bits here.
|
|
* cplus-class.c (finish_base_struct): Read bits here.
|
|
* cplus-class.c (finish_struct): If
|
|
|
|
* cplus-init.c (expand_vec_init): Implement copy initialization
|
|
from one vector to another (to make X(X&) work if members
|
|
are vectors of X). Added parameter FROM_ARRAY to signify this
|
|
fact.
|
|
* All callers changed.
|
|
|
|
* cplus-decl.c (grokdeclarator): Test for validity of destructor
|
|
declaration was too harsh. It was not allowing one to declare
|
|
that a destructor from a base class had public visibility in the
|
|
current class.
|
|
|
|
* cplus-method.c (hack_identifier): Vestigial double TREE_VALUE.
|
|
Now that we use baselinks, everything is one level of list.
|
|
|
|
* expr.c (expand_builtin): Fixed for BUILTIN_SAVEREGS case, again.
|
|
This time, loop was failing because there was only one insn being
|
|
protected. Now, emit a note, so that loop terminates properly.
|
|
|
|
* cplus-decl.c (build_default_constructor): Handle initialization
|
|
of anonymous unions by bitwise copy.
|
|
* cplus-init.c (finish_base_init): Handle wholesale initialization
|
|
of anonymous unions, i.e., the whole union, rather than just any
|
|
one member.
|
|
|
|
Sun Dec 3 13:32:29 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-decl.c (grok_ctor_properties): Add argument CTYPE to say
|
|
what class type we are grokking for.
|
|
|
|
* All GNU C++ files: Changed tests against IS_AGGR_TYPE when test
|
|
against TYPE_LANG_SPECIFIC tests the property in which we are
|
|
interested.
|
|
|
|
* cplus-decl.c (grok_ctor_properties): Notice whether constructor
|
|
can be used as default constructor, i.e., X ().
|
|
* cplus-class.c (base_info): Add new fields `needs_default_ctor'
|
|
and `cant_have_default_ctor'. Set the former if any of the
|
|
basetypes define a default constructor. Set the latter if and of
|
|
the basetypes define constructors, but not the default
|
|
constructor.
|
|
* cplus-class.c (finish_struct): If NEEDS_DEFAULT_CTOR and not
|
|
CANT_HAVE_DEFAULT_CTOR, then cons up a default constructor for T.
|
|
* cplus-lex.c (cons_up_default_function): Handle this new kind of
|
|
default constructor.
|
|
* cplus-decl.c (finish_function): Ditto.
|
|
|
|
* cplus-typeck.c (build_modify_expr): Change assignment to this
|
|
from error to warning if FLAG_THIS_IS_VARIABLE.
|
|
|
|
* cplus-class.c (finish_struct): Build default X(X&) constructor
|
|
if there are *any* constructors, not just if there are inherited
|
|
X(X&) constructors.
|
|
|
|
* integrate.c (function_cannot_inline_p): Raise threshold from 3
|
|
to 4, since we copy more NOTEs now.
|
|
|
|
* cplus-decl.c (finish_function): If DECL_CONSTRUCTOR_P (FNDECL)
|
|
and DECL_COMPILER_GENERATED_P (FNDECL), do the default thing for
|
|
this constructor (memberwise initialization). Done by calling
|
|
`build_default_constructor'.
|
|
* cplus-decl.c (build_default_constructor): New function.
|
|
|
|
* cplus-lex.c (cons_up_dtor_for_type): Change name to
|
|
`cons_up_default_function'. Takes new argument KIND saying what
|
|
kind of default function to build. Cons up destructor or X(X&)
|
|
constructor depending on KIND.
|
|
* cplus-init.c (expand_aggr_init_1): Test TYPE_HAS_INIT_REF, not
|
|
TYPE_GETS_INIT_REF.
|
|
* cplus-typeck.c (convert_for_initialization): Ditto. If !HAS,
|
|
but GETS, then abort for now.
|
|
|
|
* cplus-class.c (finish_base_struct): Propagate
|
|
TYPE_GETS_ASSIGN_REF.
|
|
* cplus-class.c (finish_struct): If TYPE_GETS_ASSIGN_REF (T)
|
|
but not TYPE_HAS_ASSIGN_REF (T), then default.
|
|
* cplus-decl.c (grok_ctor_properties): Set TYPE_HAS_INIT_REF along
|
|
with TYPE_GETS_INIT_REF.
|
|
|
|
* cplus-init.c (build_delete): Don't check PROTECT when converting
|
|
the object to be destroyed from derived type to base type.
|
|
Leave it up to whether the destructor is visible or not
|
|
to make that decision.
|
|
|
|
* cplus-typeck.c (actualparameterlist): New parameter FLAGS.
|
|
* cplus-typeck.c (convert_for_initialization): Ditto.
|
|
* cplus-cvt.c (convert_to_reference): Change PROTECT to FLAGS.
|
|
* cplus-cvt.c (build_up_reference): Ditto.
|
|
* All callers changed.
|
|
|
|
* cplus-init.c (build_delete): When deleting members, use PROTECT
|
|
rather than 1 as value for calling `build_delete' recursively.
|
|
|
|
* cplus-decl2.c (grokfield): If the initializer winds up being
|
|
`error_mark_node', wrap it in a NOP so `decl_constant_value' will
|
|
do the right thing.
|
|
|
|
* cplus-decl.c (grokparms): If default parameter needs
|
|
type instantiation, do it.
|
|
|
|
* cplus-typeck.c (build_modify_expr): Cast first expression in a
|
|
COMPOUND_EXPR to VOID_TYPE_NODE to suppress warning from
|
|
warn_if_unused_value.
|
|
|
|
Sat Dec 2 16:57:52 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c (build_scoped_method_call): Extra TREE_TYPE around
|
|
TREE_TYPE (decl) in two places. Improved comments. Make DECL be
|
|
consistently of aggregate type.
|
|
|
|
* cplus-tree.h (lang_type): `type_flags' substructure was not
|
|
multiple of 4 bytes.
|
|
|
|
Fri Dec 1 05:08:57 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* integrate.c (try_fold_cc0): Argument to `emit_jump' was wrong:
|
|
called with LABEL_REF rtx instead of underlying CODE_LABEL.
|
|
|
|
* cplus-class.c (add_virtual_function): Handle case where virtual
|
|
function is declared twice in the same class.
|
|
|
|
* cplus-decl.c (finish_decl): Length argument to `bcopy' was off
|
|
by one for anonymous aggregate names was off by one.
|
|
|
|
Thu Nov 30 16:29:42 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* expr.c (expand_builtin): In BUILTIN_SAVEREGS case, advance
|
|
SAVING_INSNS after noting stores.
|
|
|
|
Wed Nov 29 05:35:59 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-except.c (expand_cplus_reraise): If an exception was not
|
|
on the legal list of exceptions to reraise, don't bother
|
|
protecting the raised object by assigning zero to its pointer.
|
|
|
|
* cplus-class.c (build_method_call): When calling a non-const
|
|
member function from a const member function, tell which non-const
|
|
member function is being called. Also, return ERROR_MARK_NODE if
|
|
we are not looking up to complain.
|
|
|
|
* cplus-type2.c (build_functional_cast): Due to typedefs, we must
|
|
pull NAME from TYPE.
|
|
|
|
* cplus-typeck.c (build_compound_expr): If TREE_VALUE of list is a
|
|
VAR_DECL, use result of calling `decl_constant_value'.
|
|
|
|
* stmt.c (expand_end_except): PREV was uninitialized.
|
|
|
|
* stmt.c (expand_exit_except): New function, like
|
|
`expand_exit_loop'. Used to explicitly exit an except contour.
|
|
* cplus-parse.y,cplus-except.c: Replace calls to
|
|
`expand_exit_something' with calls to `expand_exit_except'.
|
|
* cplus-decl.c (start_function): If FLAG_HANDLE_EXCEPTIONS, build
|
|
an exception contour around the outermost binding level.
|
|
* cplus-decl.c (finish_function): If FLAG_HANDLE_EXCEPTIONS, clean
|
|
up that countour after the last binding contour goes away.
|
|
* stmt.c (in_{try,except}_block): Added LEVEL parameter.
|
|
* stmt.c (in_exception_handler): Added LEVEL parameter.
|
|
* cplus-except.c: All callers to `in_try_block' as about level 1
|
|
instead of immediate level, because outermost try block doesn't
|
|
really count.
|
|
|
|
* cplus-except.c (cplus_expand_end_except): Call abort if catching
|
|
unhandled exception at outermost level.
|
|
|
|
Tue Nov 28 06:51:48 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-except.c (expand_cplus_raise): Interface changed to take
|
|
third parameter which is the already-constructed object to be
|
|
raised, allowing `expand_cplus_reraise' to call this function.
|
|
|
|
* cplus-parse.y (try RERAISE raise_identifiers): Actually
|
|
implement this now.
|
|
* cplus-except.c (expand_cplus_reraise): Ditto.
|
|
|
|
* cplus-decl.c (init_decl_processing): Initialize LANG_NAME_C and
|
|
LANG_NAME_CPLUSPLUS. Initialize CURRENT_LANG_NAME to LANG_NAME_C.
|
|
* cplus-class.c (init_class_processing): Initialization of
|
|
LANG_NAME_{C,CPLUSPLUS} was too late here.
|
|
|
|
* cplus-decl.c (duplicate_decls): If NEWDECL is a FUNCTION_DECL,
|
|
and it was the last object allocated on the permanent_obstack, cut
|
|
the permanent_obstack back to NEWDECL, since we have OLDDECL.
|
|
|
|
@ The following three changes are conditional on actually defining
|
|
LANG_DECL_PERMANENT in cplus-tree.h. It is currently not defined
|
|
becuase a good solution for saving lang_decls might require more
|
|
space than the space that could be reclaimed.
|
|
|
|
@ cplus-tree.h (lang_decl): New bit LANG_DECL_PERMANENT says if
|
|
the lang_decl was allocated on the permanent_obstack.
|
|
@ cplus-lex.c (build_lang_decl): Set it if appropriate. New
|
|
variable FREE_LANG_DECL_CHAIN holds previously freed LANG_DECLs.
|
|
@ cplus-decl.c (duplicate_decls): Add the lang_decl of the old
|
|
decl to FREE_LANG_DECL_CHAIN if it was allocated on the
|
|
permanent_obstack.
|
|
|
|
* cplus-decl.c (duplicate_decls): Preserve DECL_LANGUAGE when
|
|
NEWDECL is a definition.
|
|
* cplus-decl.c (start_function): Don't set DECL_LANGUAGE here, now
|
|
that it is properly handled in `duplicate_decls'. Also, set
|
|
DECL_OVERLOADED (DECL1) from DECL_OVERLOADED (OLDDECL).
|
|
|
|
Mon Nov 27 06:30:53 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-method.c (dump_init): Argument to `dump_type' was missing
|
|
in SAVE_EXPR case.
|
|
|
|
* cplus-class.c (compute_conversion_costs): While it is probably
|
|
an error to permit a call from a const member function to a
|
|
non-const member function, cfront seems to do it, grudginly.
|
|
Change this function to make this conversion cost the heaviest of
|
|
built-in conversion costs, to give behavior that matches cfront.
|
|
This can easily be changed back to error-giving behavior.
|
|
* cplus-class (build_method_call): Give warning if calling to
|
|
non-const member function from const member function.
|
|
|
|
* cplus-method.c,cplus-class.c: Change name of
|
|
`do_actual_overload' to `build_overload_call', and move the
|
|
function from cplus-method.c to cplus-class.c. Also, rewrite
|
|
slightly to call `build_decl_overload', removing duplicated code.
|
|
* cplus-typeck.c (build_x_function_call): Change the name of
|
|
called function.
|
|
|
|
* cplus-tree.c (hash_tree_cons): Typo--set TREE_VIA_PUBLIC twice,
|
|
instead of TREE_VIA_PUBLIC and TREE_VIA_VIRTUAL.
|
|
|
|
* cplus-decl.c (finish_decl): It is INIT, and not
|
|
DECL_INITIAL (DECL) which holds the real value of DECL's
|
|
initializer. We need INIT's value for `complete_array_type' to do
|
|
its job.
|
|
|
|
* expr.c (save_noncopied_parts): Deal with case of having
|
|
`assign_stack_local' return an invalid memory reference.
|
|
|
|
* cplus-typeck.c (build_component_ref): 11/26 fix was almost
|
|
right, but called `value_member' in first case where should have
|
|
called `assoc_value'.
|
|
|
|
* cplus-init.c (expand_vec_delete): Lines were reversed in
|
|
multi-dimensional array code.
|
|
|
|
* version.c: Test release version 1.36.2-
|
|
|
|
* integrate.c (expand_inline_function): Bug in use of
|
|
CONST_EQUIV_MAP did not work correctly in the presence of loops
|
|
for variables initialized in first basic block but modified within
|
|
a loop body.
|
|
|
|
Sun Nov 26 17:11:08 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-init.c (build_new): Handle case when TRUE_TYPE gets
|
|
ERROR_MARK_NODE, such as when the size expression for an ARRAY_REF
|
|
is ERROR_MARK_NODE.
|
|
|
|
* cplus-type2.c (digest_init): Catch case where ELEMENT is
|
|
ERROR_MARK_NODE, which avoids calling `comptypes' with
|
|
ERROR_MARK_NODE as our type (recall that TREE_TYPE (ERROR_MARK_NODE)
|
|
is ERROR_MARK_NODE, not NULL_TREE).
|
|
|
|
* cplus-typeck.c (build_component_ref): Forgot to pull offset from
|
|
association of type once we found the field! This causes fields
|
|
in two separate baseclasses to overlap when referenced from a
|
|
class deriving from the baseclasses.
|
|
|
|
* cplus-parse.y (primary, primary_no_id): Recognize
|
|
`SCOPE operator_name'.
|
|
|
|
* cplus-decl.c (grok_reference_init): Code to permit references to
|
|
arrays was somehow missing. Also, in the case where DECL is
|
|
TREE_STATIC and the initializer is TREE_LITERAL, no need to call
|
|
`expand_static_init'.
|
|
|
|
* cplus-tree.h [DECL_OVERLOADED]: User `overloaded_attr' in
|
|
lang_decl to distinguish overloaded functions from nonoverloaded
|
|
ones.
|
|
* cplus-tree.h [DECL_EXTERNAL]: Use TREE_LANG_FLAG_1 instead of
|
|
TREE_LANG_FLAG_3. The latter was used for TREE_PRIVATE.
|
|
|
|
* cplus-init.c (expand_vec_delete): Handle multi-dimensional
|
|
arrays.
|
|
|
|
* cplus-decl.c (duplicate_decls): Copying of DECL_IN_AGGR_P bit
|
|
was backwards.
|
|
* cplus-decl.c (start_decl): And need to turn off DECL_IN_AGGR_P
|
|
when seeing this decl in non-aggr context. Also, clear
|
|
TREE_EXTERNAL if DECL_EXTERNAL is not set.
|
|
|
|
* cplus-decl.c (grok_reference_init): Code split from
|
|
`finish_decl' for modularity.
|
|
|
|
Sat Nov 25 06:29:08 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl.c (grokdeclarator): Was incorrectly rejecting
|
|
class-local typedefs which had things like RID_LONG (thought they
|
|
were storage class specifiers).
|
|
|
|
* cplus-method.c (report_type_mismatch): Corrected error
|
|
introduced by making INLINE_BUFFER non-static.
|
|
|
|
* cplus-tree.c (build_exception_variant): Correctly handle case
|
|
when RAISES is NULL_TREE.
|
|
|
|
* cplus-except.c (lookup_exception_object): Switch to
|
|
permanent_obstack when implicitly declaring an exception object.
|
|
|
|
* cplus-class.c (instantiate_type): Handle TREE_LIST of
|
|
FUNCTION_DECL in addition to TREE_LIST of TREE_LIST of
|
|
FUNCTION_DECL. The former is what a BASELINK in disguise.
|
|
|
|
* cplus-decl.c (grokdeclarator): Don't crash if TYPE ==
|
|
ERROR_MARK_NODE when DECL_CONTEXT == FIELD. Happens when array
|
|
size is undefined, for example.
|
|
|
|
Fri Nov 24 16:04:44 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-search.c (get_baselinks): When we get to end of search
|
|
(i.e., TYPE has only one basetype), propagate BASELINKs.
|
|
|
|
* cplus-decl.c (shadow_tag): Missing call to
|
|
`end_exception_decls'.
|
|
|
|
Tue Nov 21 23:40:57 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-method.c: Change from static allocation of INLINE_BUFFER
|
|
to dynamic, saving 8k static data size.
|
|
* cplus-method.c (fndecl_as_string): Initialize INLINE_BUFFER
|
|
always from BUF.
|
|
* cplus-class.c, cplus-tree.c: Callers of `fndecl_as_string'
|
|
changed.
|
|
|
|
Mon Nov 20 20:56:49 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c (build_method_call): Don't check visibility on
|
|
calls to wrappers.
|
|
|
|
* cplus-tree.h: Delete bitfields HAS_WRAPPER and NEEDS_WRAPPER.
|
|
Add field for TYPE_WRAP_TYPE.
|
|
* cplus-decl.c, cplus-class.c: Set fields accordingly
|
|
* cplus-class.c (build_method_call): Call `get_wrapper' if we need
|
|
to be wrapping a function call.
|
|
* cplus-search.c (get_wrapper): Implement this function.
|
|
|
|
Sat Nov 18 05:16:22 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-lex.c (check_newline): Recognize (but apologize about)
|
|
#pragma newworld.
|
|
|
|
* cplus-method.c (build_decl_overload): Compact encoding for
|
|
member functions ifndef LONGERNAMES.
|
|
* cplus-dem.c (cplus_demangle,do_args): Deal with different
|
|
encoding ifndef LONGERNAMES.
|
|
|
|
* cplus-tree.c (list_has_lookup_or_cons): New function optimizes
|
|
most common case in parsing.
|
|
* cplus-parse.y: Call in in place of `hash_tree_chain (_, NULL_TREE)'.
|
|
|
|
* cplus-parse.y, cplus-lex.c: Gather statistics on tokens and
|
|
reductions.
|
|
|
|
* cplus-class.c (instantiate_type): Forgot to check COMPLAIN
|
|
before complaining.
|
|
|
|
* cplus-init.c (build_new,build_vec_delete): Call
|
|
do_pending_stack_adjust before building and after finalizing
|
|
RTL_EXPR. Also removed bogus construct
|
|
|
|
emit_insn (gen_sequence ());
|
|
|
|
which was causing circular rtl to be output. (Thanks to rms for
|
|
identifying the problem!).
|
|
* cplus-type2.c (make_merged_ref): Same change.
|
|
* cplus-parse.y (except_stmts): Same change.
|
|
|
|
* cplus-init.c (get_member_function): Wrap a SAVE_EXPR around the
|
|
address of MEMBER.
|
|
|
|
Fri Nov 17 20:11:19 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-type2.c (store_init_value)
|
|
|
|
* cplus-dem.c (do_type): Initialize NON_EMPTY.
|
|
|
|
Tue Nov 14 00:19:31 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-init.c (build_vec_delete): Call `emit_note' in case no
|
|
code is emitted by `expand_vec_delete'.
|
|
|
|
* cplus-parse.y (operator_name): If the operator name is
|
|
erroneous, build something signifying that fact, rather than just
|
|
returning NULL_TREE.
|
|
|
|
* cplus-typeck.c (target_type): New function. Returns the target
|
|
type of TYPE.
|
|
* cplus-decl.c (finish_decl): Call `target_type' to figure out the
|
|
built-in type that DECL is based on. If we find it to be
|
|
ANON_AGGRNAME_P, then we must change it, since nothing else will,
|
|
and the compiler will go into loops if expand_inline_function trys
|
|
to push it back into the environment.
|
|
|
|
* cplus-parse.y (primary): Need to do `lookup_name' on operator
|
|
names that come through here.
|
|
|
|
* stmt.c (expand_end_try): Jump to after label to avoid falling
|
|
through into default handler.
|
|
|
|
* cplus-decl.c (define_label): Don't complain about jumps past
|
|
initialziation of compiler-generated temporaries. They can't be
|
|
accessed, and by the time we get to the label, they should be
|
|
cleaned up.
|
|
|
|
Mon Nov 13 02:34:58 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-init.c (get_member_function): If EXP_ADDR was something
|
|
hairy (like a CALL_EXPR), make EXP indirect from it. This saves
|
|
writing out twice the code (once for each branch of the
|
|
conditional).
|
|
|
|
* cplus-dem.c (cplus_demangle): Recognize virtual function tables.
|
|
* Also, handle operator* and operator->().
|
|
|
|
* cplus-class.c (finish_struct): Don't warn about all class
|
|
members being private if there are public baseclasses.
|
|
|
|
* cplus-decl.c (grokdeclarator): Catch case where friend function
|
|
is declared with method qualifiers.
|
|
|
|
* cplus-typeck.c (commontype): Get the right value for BASETYPE in
|
|
METHOD_TYPE case.
|
|
|
|
* cplus-method.c (build_opfncall): TYPE1 was being initialized too
|
|
late.
|
|
|
|
* cplus-dem.c[USG]: Use this instead of #ifndef sequent.
|
|
|
|
Sun Nov 12 01:35:08 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* integrate.c (note_integrated): New function. If insn generated
|
|
used constants, check that it is legit. If not, delete it and
|
|
return zero to caller, indicating that the caller should try
|
|
again. If successful, set RTX_INTEGRATED_P.
|
|
|
|
* cplus-tree.c (layout_vbasetypes): Use `int' return type to
|
|
advantage.
|
|
|
|
* cplus-init.c (build_delete): Don't abort if TYPE ==
|
|
ERROR_MARK_NODE. It can happen.
|
|
|
|
* integrate.c: Use "iteration numbering" to propagate constants
|
|
through inline function expansion.
|
|
|
|
* stmt.c: Added exception stmts to nesting stack.
|
|
* cplus-except.c: Move appropriate stuff out of here.
|
|
|
|
Sat Nov 11 10:10:59 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* integrate.c: Make `expand_inline_function' smart enough to use
|
|
constant when safe, and not when not.
|
|
|
|
* integrate.c: Merged changes from rms as of today.
|
|
* varasm.c: Merged changes from rms as of today.
|
|
|
|
* cplus-except.c: Use variable TRY_DEPTH to determine whether we
|
|
are inside a TRY block or not.
|
|
* cplus-except.c (cplus_expand_{start,end}_try):
|
|
Increment/decrement that variable.
|
|
* cplus-except.c (expand_cplus_raise_stmt): If TRY_DEPTH is
|
|
nonzero, then simply exiting the try block does all the right
|
|
things. Otherwise, we must use `longjmp'.
|
|
|
|
* cplus-init.c (build_new): Don't use the RTL_EXPR hack for static
|
|
initializations.
|
|
|
|
* ld.c (write_output): Unconditionally remove the old file in case
|
|
another owns it but user has write permission.
|
|
|
|
* cplus-decl2.c (finish_file): Set DECL_PRINT_NAME of file
|
|
clean/initialization functions to things we might want to print.
|
|
|
|
Fri Nov 10 19:08:51 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-tree.h: Get rid of EXCEPTION_LABEL_DECL, no longer needed.
|
|
Add EXCEPTION_THROW_DECL. This VAR_DECL is used to determine
|
|
whether to throw from a binding contour using the exception
|
|
handling machinery.
|
|
* cplus-decl.c, cplus-except.c: Changes to adapt to new model.
|
|
|
|
* tree.c (build_op_identifier): #if 0 in this file.
|
|
* cplus-lex.c (build_op_identifier): define this function here.
|
|
Change interface to take `tree_code' arguments instead of `tree'
|
|
arguments. Use memoizing table to preserve previously allocated
|
|
nodes.
|
|
* cplus-parse.y, cplus-method.c: Callers changed.
|
|
* cplus-lex.c (build_operator_fnname): Can't get by on
|
|
side-effecting an OP_IDENTIFIER's TREE_CODE anymore. Change
|
|
interface to pass OP_IDENTIFIER node in as a tree*, and set that.
|
|
* cplus-decl2.c (grokopexpr): Must also take DECLARATOR in as
|
|
pointer.
|
|
|
|
* cplus-init.c (build_new): After calling `start_sequence', prime
|
|
the insn pump by calling `emit_note' to emit a NOTE_INSN_DELETED.
|
|
|
|
Wed Nov 8 15:54:32 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-type2.c (build_functional_cast): Move from cplus-class.c
|
|
to this file.
|
|
|
|
* cplus-class.c (build_functional_cast): Don't assume that
|
|
TYPE_NAME (TYPE) is a TYPE_DECL; it might be an IDENTIFIER_NODE.
|
|
|
|
* gcc.c (main): Print out the name `g++' instead of `gcc' until
|
|
the merge is complete.
|
|
|
|
Tue Nov 7 14:56:50 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-init.c (build_new): Initialize RVAL if SOS.
|
|
|
|
Mon Nov 6 00:51:43 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* crt1.c: Changes from Eirik Fuller (Cornell Theory Center) to fix
|
|
incremental linking.
|
|
* gnulib3.c (__do_global_cleanup): Also from Eirik: fixed braino
|
|
that was not reinitializing __DLI.
|
|
|
|
* cplus-method.c (build_overload_name): Mangle member functions
|
|
with qualifiers differently than member functions without
|
|
qualifiers. Also, add 'F' before argument list for METHOD_TYPE,
|
|
since cfront 2.0 seems to do so.
|
|
* cplus-method.c (dump_type_suffix): Make formatting of these
|
|
kinds of METHOD_TYPEs right.
|
|
* cplus-dem.c (do_type): Grok these changes.
|
|
|
|
* cplus-except.c (exception_object_name): Don't crash in case
|
|
of ``raise all'', which comes encoded as VOID_TYPE_NODE.
|
|
@@ Handle it correctly in next release.
|
|
|
|
* cplus-decl2.c (grok_method_quals): New function. Incorporate
|
|
`const' and `volatile' qualifiers into FUNCTION_DECLs and
|
|
TYPE_DECLs. Uses code broken out of `grokclassfn'.
|
|
* cplus-decl2.c (grokclassfn): Caller changed.
|
|
* cplus-decl.c (grokdeclarator): Call `grok_method_quals' when
|
|
QUALS is non-zero in declarator grokking loop.
|
|
|
|
Sat Nov 4 20:21:54 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-init.c (build_new): If TYPE_NEEDS_CONSTRUCTING (TYPE),
|
|
then always wrap RVAL in an RTL_EXPR, since we don't know that we
|
|
aren't one of the arms of a ?: operation. RVAL can now be a
|
|
SAVE_EXPR (normally) or a VAR_DECL (in the case of array
|
|
initialization).
|
|
|
|
* cplus-init.c (build_new): Fix braino that was causing array
|
|
types to be collapsed into their element types, causing
|
|
`build_new' to return a point to the element type, rather then a
|
|
pointer to the array type.
|
|
|
|
* cplus-decl2.c (grokfield): Check DECL_NAME (VALUE) before
|
|
dereferencing it.
|
|
|
|
* cplus-init.c (expand_vec_init): Do not fail to initialize
|
|
element of an array which receive default initialization.
|
|
|
|
* cplus-type2.c (digest_init): If TYPE needs constructing,
|
|
don't convert INIT to TYPE. The only time when this happens
|
|
is when called upon to initialize an ARRAY_TYPE, and
|
|
`expand_vec_init' will handle that case.
|
|
|
|
* cplus-class.c (build_method_call): Error reporting for bad
|
|
argument list was screwed for static member functions in static
|
|
call context.
|
|
|
|
* config.g++: Add MIPS-based configurations.
|
|
|
|
* toplev.c: Make up for systems which do not have unistd.h (like
|
|
many BSD systems).
|
|
* Makefile: Add HAVE_UNISTD_H flag.
|
|
|
|
* cplus-dem.c: Sequentize the code.
|
|
|
|
* cplus-init.c (expand_cplus_expr_stmt): Warn if statement is just
|
|
a reference to, and not a call of, some function.
|
|
|
|
Thu Nov 2 10:03:50 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-method.c (build_overload_name): Don't crash if we built a
|
|
TREE_LIST which contains VOID_TYPE_NODE and which is not
|
|
VOID_LIST_NODE. This happens if one of the parameters is of type
|
|
VOID_TYPE.
|
|
|
|
* stmt.c (expand_return): Even when RETVAL has type VOID_TYPE, we
|
|
must expand it (it may be a call to another void function).
|
|
|
|
* integrate.c (copy_rtx_and_substitute): Moved one to many insns
|
|
to BEFORE_INLINE_FP_RTX.
|
|
|
|
* cplus-typeck.c (convert_for_initialization,actualparameterlist):
|
|
Don't defaultly convert ARRAY_TYPE when converting to
|
|
REFERENCE_TYPE.
|
|
|
|
Wed Nov 1 04:43:46 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* stmt.c (init_function_start): Initialize MAX_PARM_REG to
|
|
FIRST_PSEUDO_REGISTER.
|
|
|
|
* cplus-init.c (expand_vec_init): This function can be called to
|
|
initialize a non-aggregate vector.
|
|
|
|
Tue Oct 31 13:38:42 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-type2.c (process_init_constructor): Don't even try
|
|
initializing a structure from EMPTY_INIT_NODE.
|
|
|
|
* cplus-init.c (build_new): Handle case where SAVE_EXPR_RTL of
|
|
new'd value is 0 by putting it CONST0_RTX.
|
|
|
|
* cplus-typeck.c (build_component_ref): If the COMPONENT_REF is
|
|
really a reference to a member function, do the right thing if the
|
|
member function is virtual.
|
|
|
|
Mon Oct 30 00:39:18 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c (build_method_call): Removed code that seemed to
|
|
build (superflouously) an INDIRECT_REF for INSTANCE just before
|
|
heading to found/found_and_ok (where INSTANCE was just
|
|
reinitialized). Also, fixed bug so that if INSTANCE was of fixed
|
|
type, that fact remained known even if INSTANCE_PTR became more
|
|
distanct due to going through a NOP_EXPR.
|
|
|
|
* cplus-init.c (get_member_function): Add parameter EXP_ADDR_PTR
|
|
which is a pointer to the tree representing the address of EXP.
|
|
Also, add hairy code which does the right thing wrt. modifying
|
|
`this' pointer when it is argument to call.
|
|
@@ This modification causes GNU C++ to generate stupid
|
|
conditional-branch code when optimizing. Hopefully future
|
|
versions of the optimizer will understand and optimize it.
|
|
* cplus-typeck.c (build_x_function_call): Caller changed.
|
|
|
|
* cplus-tree.h (lang_type): Added new field GOT_SEMICOLON to
|
|
TYPE_FLAGS field, to record whether a type has been `finished' or
|
|
not. Attempt to catch bugs like `struct s { .. } main () { .. }'.
|
|
* cplus-parse.y (various rules): Add call to `note_got_semicolon'.
|
|
* cplus-decl.c (start_function): Check that we have a `finished'
|
|
type.
|
|
* cplus-lex.c (note_got_semicolon): Set the bit here.
|
|
* cplus-class.c (finish_struct): Whenever we start afresh with a
|
|
class type, zero the bit here.
|
|
|
|
* cplus-type2.c: Rename file cplus-typeck2.c to fit brain-damaging
|
|
SVID 14 char name limit.
|
|
|
|
* cplus-typeck.c (build_modify_expr): Handle case where assignment
|
|
comes from friend, rather than member function.
|
|
|
|
* cplus-tree.c (lang_printable_name): Handle case where DECL's
|
|
language specific field is nonexistent.
|
|
* cplus-method.c (fndecl_as_string): Here too.
|
|
|
|
* cplus-decl.c (finish_decl): Initialization of a reference from
|
|
`*this' was falling down because nodes for `$this' were getting
|
|
shared too much.
|
|
|
|
* cplus-tree.h (TREE_HAS_CONSTRUCTOR): Reincarnate use of this
|
|
flag--for SAVE_EXPR it means that underneath lies a call to
|
|
`new' for a given type.
|
|
* cplus-init.c (build_new): Set the flag.
|
|
* cplus-method.c (dump_init): Test it.
|
|
|
|
* cplus-tree.h (PARM_DECL_EXPR): Use this flag to distinguish
|
|
parsing initializers for PARM_DECLs from initializers for global
|
|
variables.
|
|
* cplus-decl2.c (finish_file): Don't emit anything from
|
|
STATIC_AGGREGATES that was really just for default parameters.
|
|
* cplus-decl.c (grokparms): Set PARM_DECL_EXPR on SAVE_EXPRs.
|
|
* cplus-method.c (dump_init): Same.
|
|
|
|
Sun Oct 29 23:23:48 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-method.c (build_opfncall): Don't check visibility here for
|
|
operators `new' and `delete' unless within a constructor or
|
|
destructor.
|
|
* cplus-decl.c (finish_function): Add checks for visibility of
|
|
those operators here instead.
|
|
|
|
* cplus-decl2.c (groktypefield): Handle case where field name
|
|
conflicts with a typedef.
|
|
|
|
Fri Oct 27 01:02:20 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-search.c (get_virtuals_named_this): Return a baselink
|
|
instead of a FUNCTION_DECL. Also, walk through FIELDS as
|
|
baselinks. I.e., use `next_baselink' instead of TREE_CHAIN.
|
|
|
|
* cplus-search.c (get_first_matching_virtual): Caller changed.
|
|
|
|
Thu Oct 26 16:09:07 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-search.c (get_first_matching_virtual): Only complain about
|
|
a particular property of a virtual function once.
|
|
|
|
* cplus-class.c (finish_struct): If ASSOC winds up being zero,
|
|
don't frob the vtable.
|
|
|
|
* cplus-decl.c (shadow_tag): Handle case where exception does not
|
|
have any fields.
|
|
* cplus-parse.y (component_decl): Handle case where exception does
|
|
not have any fields.
|
|
|
|
* cplus-parse.y (structsp): Call `finish_exception' with only two
|
|
parameters.
|
|
|
|
* cplus-parse.y (stmt): Forgot ';' after `RAISE' stmt.
|
|
|
|
* cplus-class.c: Gather statistics on number of elments in virtual
|
|
function tables, number of entries we build for them, and number
|
|
of virtual function table entries we search using linear lookup.
|
|
|
|
* cplus-parse.y (aggr,opt.component_decl_list): Call
|
|
`build_tree_list' instead of `decl_tree_list', because of nested
|
|
structures. Would be better to make TEMP_DECL_OBSTACK pushable
|
|
like the momentary obstack, but we don't for now.
|
|
|
|
Tue Oct 24 06:26:13 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* integrate.c (copy_rtx_and_substitute): Don't change something to
|
|
a memory address unless it really is `memory_address_p'.
|
|
|
|
* cplus-decl.c (finish_decl): Handle array initialization if type
|
|
of array needs constructor. Also, implement initialization
|
|
without INIT0 crutch.
|
|
* cplus-init.c (expand_vec_init): Handle array initialization from
|
|
{...} where type of array needs constructor.
|
|
|
|
* cplus-typeck.c (build_binary_op_nodefault): Make compiler give
|
|
error, not warning, if comparing pointers with integers.
|
|
|
|
* cplus-typeck.c (build_component_ref): Call `lookup_fnfields' to
|
|
get a list of methods.
|
|
|
|
Mon Oct 23 17:29:03 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-tree.h (lang_decl): Add bit `COMPILER_GENERATED' to
|
|
indicate whether this FUNCTION_DECL was generated automatically by
|
|
the compiler.
|
|
* cplus-lex.c (cons_up_dtor_for_type): Set this bit.
|
|
* cplus-decl.c (redeclaration_error_message): Give better error
|
|
message if user redeclares something that was implicitly created
|
|
by the compiler.
|
|
|
|
* cplus-decl.c (finish_decl): Test DECL_LANG_SPECIFIC before
|
|
testing DECL_IN_AGGR_P in case of init-free reference decl.
|
|
|
|
Sat Oct 21 10:29:09 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c (build_method_call): Forgot to increment b_or_d as
|
|
we go through class hierarchy. Probably fell out as a result of
|
|
`next_baselink' change on Friday, Oct 13.
|
|
|
|
* cplus-cvt.c (build_up_reference): When calling
|
|
`convert_to_nonzero_pointer', use TYPE_MAIN_VARIANT so that
|
|
TYPE_POINTER_TO is defined.
|
|
|
|
* cplus-search.c ({push,pop}_memoized_context): Plug memory leak
|
|
by freeing pushing and popping the TYPE_OBSTACK irrespective of
|
|
whether we are memoizing lookups or not.
|
|
|
|
* cplus-decl2.c (grokclassfn): Don't make `this' TREE_READONLY
|
|
inside of destructors.
|
|
|
|
* cplus-search.c (get_abstract_virtuals): New function. Returns
|
|
the list of virtual functions that are considered abstract for a
|
|
given type (i.e., those which are ` = 0' in declaration).
|
|
* cplus-class.c (finish_base_struct): Call it.
|
|
|
|
* All GNU C++ files: change names containing `UNINHERIT*' to names
|
|
containing `ABSTRACT'. Eliminate use of
|
|
CLASSTYPE_HAS_ABSTRACT_VIRTUALS in favor of testing
|
|
CLASSTYPE_ABSTRACT_VIRTUALS directly.
|
|
|
|
* cplus-decl.c (start_function): Handle case where user names and
|
|
internal names conflict.
|
|
|
|
* cplus-typeck.c (build_conditional_expr): Put type instantiation
|
|
back in.
|
|
|
|
* cplus-decl.c (start_function): Use DECL_STATIC_CONTEXT instead
|
|
of DECL_CONTEXT for pushing into context of static function.
|
|
|
|
* cplus-decl.c (auto_function): Like `builtin_function', but
|
|
builds an overloadable function.
|
|
* cplus-decl.c (init_decl_processing): Call it for __builtin_new,
|
|
__builtin_delete and similar functions.
|
|
|
|
Fri Oct 20 02:22:06 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-decl.c (finish_decl): Set TREE_USED bit of DECL if DECL is
|
|
a const VAR_DECL at TOPLEVEL.
|
|
|
|
* cplus-class.c (modify_vtable_entry): Still more fixes to code
|
|
which computes derived vtable.
|
|
|
|
Thu Oct 19 11:14:55 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c (finish_struct): Move code that sets
|
|
TYPE_USES_MULTIPLE_INHERITANCE from here...
|
|
* cplus-decl.c (xref_tag): ...to here.
|
|
|
|
* cplus-decl.c (finish_decl): Oct 12 change to implement
|
|
initialization of class members so that their initializers could
|
|
use private members did not test DECL sufficiently. In addition
|
|
to checking DECL_CONTEXT, must also check that TREE_CODE (DECL) ==
|
|
VAR_DECL. Otherwise redeclaration of member functions cause
|
|
crashes.
|
|
|
|
Tue Oct 17 03:34:05 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-method.c (hack_identifier): Use `error', not
|
|
`error_with_decl' to report that a non-static member is being
|
|
referenced in a static member function.
|
|
|
|
* cplus-decl.c (duplicate_decls): TREE_INLINE was not being set
|
|
for OLDDECL, which is really where it matters.
|
|
|
|
* cplus-typeck2.c (merge_component_comparisons): Track TEM1 in
|
|
addition to TEM0 in loop which computes BITPOS0.
|
|
|
|
* cplus-decl2.c (grokfield): Set CLASSTYPE_LOCAL_TYPEDECLs from
|
|
CURRENT_CLASS_TYPE rather than DECL_CONTEXT (VALUE), since the
|
|
latter is not set up for TYPE_DECLs.
|
|
|
|
* cplus-decl.c (xref_tag): Set CLASSTYPE_DECLARED_CLASS each time
|
|
we see an xref to this tag until we see the actual type defined
|
|
for this tag.
|
|
|
|
Mon Oct 16 01:48:27 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-tree.h (DECL_VIRTUAL_P): If set in an IDENTIFIER_NODE, it
|
|
means that somebody has defined a virtual function with this name.
|
|
* cplus-decl.c (grokfndecl): Set it.
|
|
* cplus-search.c (get_first_matching_virtual): Use it.
|
|
|
|
* cplus-decl.c (cplus-tree.h): Define DECL_EXTERNAL as synonym for
|
|
TREE_LANG_FLAG_3, which means for a VAR_DECL to mean that `extern'
|
|
was specified in for that VAR_DECL.
|
|
* cplus-decl.c (grokvardecl): Set DECL_EXTERNAL.
|
|
* cplus-decl.c (duplicate_decls): Set TREE_PUBLIC of `const'
|
|
variables based on TREE_STATIC and DECL_EXTERNAL.
|
|
|
|
Sun Oct 15 00:44:01 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-decl.c (start_function): Set CURRENT_EXTERN_INLINE from
|
|
TREE_PUBLIC of DECL1 if DECL1 came pre-parsed.
|
|
|
|
* cplus-decl2.c (finish_file): Don't write out inline functions
|
|
which had their address taken if they were declared
|
|
`extern inline'.
|
|
|
|
* cplus-decl.c (grokdeclarator): Don't set TREE_PUBLIC based on
|
|
INLINEP here. Also, don't treat RID_INLINE as being a storage
|
|
class for `multiple storage classes' error message.
|
|
* cplus-decl2.c (grokfield): Do it instead here.
|
|
* cplus-init.c (do_friend): And here.
|
|
* cplus-decl.c (duplicate_decls): And change this to more match
|
|
how GCC does things.
|
|
|
|
* cplus-lex.c [USG_STDIO]: Use this instead of USG, for turncoats
|
|
who have enough of System V that their stdio is broken, and too
|
|
much Berkeley for USG to be the right thing.
|
|
|
|
* cplus-decl.c (grokdeclarator): Grok declarations of the form
|
|
`X x(args)[size]' to mean ARGS is an initializer to the array
|
|
constructor for X[SIZE].
|
|
* cplus-decl2.c (finish_file): Handle new case.
|
|
|
|
* cplus-method.c (build_opfncall): Don't abort if user makes a bad
|
|
call to operator new. It's not the compiler's fault.
|
|
|
|
* cplus-init.c (finish_base_init): Unmark virtual baseclasses
|
|
which have explicit initializers.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): Change PROTECT parameter to
|
|
FLAGS parameter. All callers changed.
|
|
|
|
* cplus-decl.c (finish_function): In destructor code, it is
|
|
CLASSTYPE_VSIZE, not TYPE_VIRTUAL_P, which is the operative
|
|
value to test when building base destructor code. See Sept 1
|
|
change for more info.
|
|
|
|
* cplus-parse.y (unary_expr): Arguments to build_vbase_delete were
|
|
wrong: was passing POINTER_TYPE and address when should have been
|
|
passing object type and object.
|
|
|
|
Sat Oct 14 06:45:34 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* stmt.c (expand_anon_union_decl): For anonymous unions in memory,
|
|
don't call `change_address'. Just cast the memory reference
|
|
ourselves.
|
|
|
|
* cplus-typeck2.c (store_init_value): Don't test PEDNATIC to see
|
|
whether to permit initialization of static variable from
|
|
non-constant, since C++ 2.0 defines it to work.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): PARM_SLOTS was allocating
|
|
sizeof (char) instead of sizeof (struct rtx_def*).
|
|
|
|
* cplus-decl.c (grokfndecl): Call to `get_first_matching_virtual'
|
|
must be followed by code which, under certain cases, goes all the
|
|
way down the inheritance hierarchy to match the virtual function.
|
|
Otherwise, the wrong virtual function tables come in to play when
|
|
the time comes to reconcile them (in modify_vtable_entry). Note
|
|
that the call to `get_first_matching_virtual' does the right thing
|
|
within `finish_struct'. In that case, since we pull BASE_FNDECL
|
|
from a virtual base class's virtual function table, there is no
|
|
issue where it should be thought of as coming from.
|
|
|
|
* cplus-search.c (rank_mi_virtuals): Spurious TREE_TYPE made it
|
|
look like we were trying to compare PARM_DECLs instead of _TYPE
|
|
nodes in our list at some time.
|
|
|
|
* cplus-search.c (get_first_matching_virtual): Friday the 13th
|
|
change was wrong. Instead, make `get_first_matching_virtual'
|
|
handle the instance variable itself, and call `compparms' as
|
|
before.
|
|
|
|
* cplus-lex.c (reinit_parse_for_method): Null character was being
|
|
inserted if USG hack to round up buffer length was being used.
|
|
|
|
* cplus-class.c (compute_conversion_costs): When trying a type
|
|
conversion, use the actual type that the function wants. No
|
|
reference-bashing here!
|
|
|
|
* cplus-search.c: Add a new obstack BRIDGE_OBSTACK which contains
|
|
the class declarations across scopes. This is an alternative to
|
|
building their lists on the permanant_obstack.
|
|
* cplus-search.c (push_search_level): Record the obstack for which
|
|
this level was pushed.
|
|
* cplus-search.c (pop_search_level): Remove OBSTACK parameter.
|
|
Get that value from the search level that is being popped.
|
|
|
|
* cplus-tree.h (lang_type): Add a slot for the instance variable.
|
|
* cplus-decl.c (start_function): Use it.
|
|
|
|
* tree.c (build_nt0): New function. Use this to build declarators
|
|
instead of `build_nt'. Uses new obstack `temp_decl_obstack'.
|
|
|
|
* cplus-cvt.c (build_type_conversion): Distinguish void* from
|
|
const void* if we are trying to convert from some arbitrary
|
|
pointer to a void* variant.
|
|
|
|
* cplus-class.c (finish_struct_bits): New function. Code broken
|
|
out of `finish_struct'. Extend to handle both conversions to
|
|
const pointers and conversions to non-const pointers.
|
|
|
|
* cplus-tree.h (lang_type): Extend to handle both conversions to
|
|
const pointers and conversions to non-const pointers.
|
|
|
|
* cplus-decl.c (start_function): FNTYPE was not re-set after
|
|
calling `pushdecl'. Consequently, static member functions with
|
|
default arguments were breaking.
|
|
|
|
* cplus-class.c (pushclass): When pushing tags into the class
|
|
binding level, push the TYPE_DECL, not the _TYPE into the
|
|
IDENTIFIER_CLASS_VALUE slot.
|
|
|
|
* cplus-method.c (fndecl_as_string): Don't skip first parameter if
|
|
FNDECL is a static member function.
|
|
|
|
* gplus.gperf [CATCH]: Add it.
|
|
|
|
* cplus-init.c (build_member_ref): Nodes returned from
|
|
lookup_fnfields are not saved on the permanent obstack, regardless
|
|
of CURRENT_OBSTACK. This is usually ok, since they are usually
|
|
only used as a structure through which search machinery will
|
|
traverse looking for values that do live on the permanent obstack.
|
|
One exception is when `build_member_ref' builds an expression
|
|
which requires type instantiation at top-level.
|
|
|
|
* cplus-decl.c (finish_decl): Give better error messages for
|
|
initialization of references, and remove invalid messages as well.
|
|
Initialization of type-qualified references is different than
|
|
initialization of type-qualified pointers in the following way:
|
|
you can initialization a `X&' from a `const X&', but you cannot
|
|
initialize a `X*' from a `const X*'. This is because the compiler
|
|
can convert the `const X&' to a `const X', create a new temporary,
|
|
and take a reference from that.
|
|
|
|
* cplus-init.c (is_friend): In testing for friendly classes, allow
|
|
for static member functions to be considered friends.
|
|
|
|
Fri Oct 13 00:03:18 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-decl.c (grokdeclarator): If DECL_CONTEXT is FIELD for
|
|
building a TYPE_DECL, allocate using `build_lang_field_decl'
|
|
instead of `build_decl'.
|
|
|
|
* cplus-decl.c (xref_tag): Undo Sept 10 change. It causes
|
|
problems for InterViews. Better to work around in ET++.
|
|
|
|
* cplus-decl.c (lookup_name): When looking up NAME, if
|
|
CURRENT_CLASS_TYPE is being defined, check its baseclasses for a
|
|
definition of a TYPE_DECL.
|
|
|
|
* cplus-decl.c (grok_enum_decls): Return DECL, not NULL_TREE if
|
|
TYPE has already been recorded.
|
|
|
|
* cplus-search.c (dfs_pushdecls): Push class-local TYPE_DECLs into
|
|
IDENTIFIER_CLASS_VALUEs.
|
|
|
|
* cplus-typeck.c (c_expand_return): Call `expand_cleanups_to' with
|
|
NULL argument in case the return value generated cleanups for its
|
|
call.
|
|
|
|
* stmt.c (expand_anon_union_decl): Fixed so that MEM anon unions
|
|
are correctly handled.
|
|
|
|
* cplus-decl2.c (finish_anon_union): Handle non-global static
|
|
anonymous unions.
|
|
|
|
* cplus-decl.c (shadow_tag): Change int variable OK to enum
|
|
tree_code OK_CODE, remembering the value of the code we though was
|
|
ok. This avoids being confused when other legitimate DECLSPECS
|
|
(such as `static') appear after one like `union ...'.
|
|
|
|
* cplus-class.c (popclass): When popping from a class's scope,
|
|
back to another class's scope, restore CURRENT_VTABLE_DECL only if
|
|
we had one before.
|
|
|
|
* cplus-decl2.c (grokfield): Push TYPE_DECL into class level as
|
|
soon as we see it.
|
|
|
|
* cplus-class.c (instantiate_type): In ADDR_EXPR case, complain if
|
|
type we are instantiating to is not POINTER_TYPE.
|
|
|
|
* cplus-decl.c (start_method): Call `preserve_data' to save the
|
|
parameters (which were read into the maybepermanent obstack).
|
|
|
|
* cplus-typeck2.c (digest_init): Handle case of union with
|
|
constructor.
|
|
|
|
* cplus-init.c (build_member_ref): Vestigial bug from change in
|
|
representation of method lists (from list of lists to list of
|
|
chains).
|
|
|
|
* cplus-class.c (instantiate_type): Rewrite TREE_LIST case to use
|
|
`next_baselink' when appropriate, and to try overloading based on
|
|
non-member functions if that looks appropriate.
|
|
|
|
* cplus-search.c (next_baselink): New function. Contains code
|
|
broken out of `build_method_call' to advance to next chain of
|
|
FUNCTION_DECLs.
|
|
|
|
* cplus-init.c (build_member_ref): If member ref is a reference to
|
|
non-unique member function, return a BASELINK (which is a list of
|
|
lists) rather than a list containing just that type's methods with
|
|
that name.
|
|
|
|
* cplus-init.c (resolve_member_ref): Handle uninstantiated method
|
|
types.
|
|
|
|
* cplus-decl.c ({start,finish}_decl): Call pushclass/popclass for
|
|
decls which are static class members, in order to perform
|
|
visibility computations for initializers correctly.
|
|
* cplus-decl.c (grokvardecl): If static class member, set
|
|
DECL_CONTEXT of the decl to the containing class type.
|
|
|
|
* cplus-search.c (get_first_matching_virtual): Must call comptypes
|
|
starting from first parameter, not its TREE_CHAIN, since one
|
|
version of the function may have a this which is `*const' while
|
|
the other does not.
|
|
|
|
* cplus-decl.c (finish_decl): Permit static class members of
|
|
reference type to be uninitialized in class declaration. They
|
|
will get initialized elsewhere, presumably.
|
|
|
|
* cplus-method.c (dump_type_prefix): `const' and `volatile' were
|
|
being put in the wrong places. Type like `const *const ...' were
|
|
being dumped as `const const *...'.
|
|
|
|
* cplus-decl2.c (finish_file): Don't try to initialize anything
|
|
which has ERROR_MARK_NODE in its initializer.
|
|
|
|
Thu Oct 12 02:41:34 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-init.c (resolve_member_ref): Catch case when we are in
|
|
static member function context by reference is to (apparently)
|
|
non-static member.
|
|
|
|
* cplus-method.c (fndecl_as_string): Check PARMTYPES before
|
|
chaining down, in case of syntax error.
|
|
|
|
* cplus-init.c (do_friend): Take QUALS parameter. Needed for
|
|
`grokclassfn'. Also take CTYPE instead of CNAME parameter.
|
|
* cplus-decl.c (grokdeclarator): Caller changed.
|
|
|
|
* cplus-init.c (do_friend): Set DECL_CONSTRUCTOR_P bit if we get a
|
|
constructor.
|
|
|
|
* cplus-tree.c (layout_basetypes): Don't allocate a virtual
|
|
baseclass pointer if we can share one with a non-virtual
|
|
baseclass.
|
|
|
|
* tree.c (make_node): Build PARM_DECL nodes on the
|
|
maybepermanent_obstack, not on the permanent_obstack.
|
|
|
|
* cplus-typeck.c (build_unary_op): If addressing a reference and
|
|
the reference is a variable, we need to check DECL_INITIAL, in
|
|
case the variable is being initialized by a function call at top
|
|
level.
|
|
|
|
* cplus-decl.c (grokdeclarator): Be more careful when looking for
|
|
function name when giving error that parameter list is random.
|
|
|
|
* cplus-decl.c (grokdeclarator): Change handling of STATICP for
|
|
member functions. Eliminate variable MEMFUNC_STATICP.
|
|
|
|
* cplus-decl.c (init_decl_processing): Don't disable profiling
|
|
anymore.
|
|
|
|
Wed Oct 11 05:37:12 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* c plus-except.c [_JBLEN]: More systems have more ways to fail to
|
|
define this value. Implement yet another way to get it.
|
|
|
|
* cplus-typeck.c (build_component_ref): Have to really check
|
|
whether FIELD comes from a virtual baseclass.
|
|
|
|
* cplus-init.c (is_aggr_typedef): Renamed
|
|
`is_aggr_typedef_or_else' to `is_aggr_typedef', and gave it
|
|
OR_ELSE parameter. All callers changed.
|
|
* cplus-parse.y (member_init): Call `is_aggr_typedef' with zero
|
|
value for OR_ELSE. We just want to know if the member looks like
|
|
a virtual baseclass member or not.
|
|
|
|
* cplus-method.c (build_decl_overload): Handle case where error
|
|
has us building an overloaded name for something with a signature
|
|
of X::f (...). That signature is technically erroneous, but can
|
|
arise in the face of certain syntax errors.
|
|
|
|
* cplus-lex.c (yylex): Handling of extern language strings was
|
|
broken. If we were unlucky and got a file name string while
|
|
reading a declaration, it could cause YYLVAL.TTYPE to contain the
|
|
filename, rather than the type that was read in. Fixed by
|
|
assigning to YYLVAL.TTYPE after checking for possible language
|
|
string identifier.
|
|
|
|
* cplus-init.c (build_new): We cannot expand `new' inside of base
|
|
or member initializers, so instead put the expansion into an
|
|
RTL_EXPR. CURRENT_VTABLE_DECL is ERROR_MARK_NODE in that case.
|
|
* cplus-parse.y (.set_base_init): Set CURRENT_VTABLE_DECL to
|
|
ERROR_MARK_NODE to indicate we are in initialization.
|
|
* cplus-class.c (build_vfn_ref): Don't use cached vtable if
|
|
calling function from base or member initializer.
|
|
|
|
Tue Oct 10 22:47:47 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-typeck.c (unary_complex_lvalue): Can't take pointer to
|
|
member through virtual baseclass.
|
|
* cplus-typeck.c (convert_for_assignment): Same change.
|
|
|
|
* stmt.c (assign_parms): Don't let BLKmode parameter get
|
|
``rounded'' off its word boundary...`access_parm_map' does not
|
|
know what to do if that should happen for an inline function.
|
|
|
|
* cplus-decl.c (grokdeclarator): Distinguish STATICP, which has
|
|
roughly the usual `C' meaning, from MEMFUNC_STATICP, which means
|
|
that the declaration is a static member function.
|
|
|
|
Mon Oct 9 00:55:19 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-method.c (build_overload_name): Change naming scheme so
|
|
that GNU calling convention (which passes objects in the stack) is
|
|
distinct from cfront/PCC convention.
|
|
|
|
* cplus-decl.c (push_overloaded_decl): Don't compare DECL_LANGUAGE
|
|
of previously overloaded decl if it is not a FUNCTION_DECL.
|
|
|
|
* cplus-decl.c (grokfndecl): Use parameter CHECK to control
|
|
behavior of `grokclassfn' in non-constructor case (already used in
|
|
constructor case).
|
|
|
|
* cplus-class.c (finish_struct): Give warning if struct or union
|
|
has no data members if PEDANTIC *or* EXTRA_WARNINGS.
|
|
|
|
* cplus-typeck.c (convert_for_initialization): Don't forget to
|
|
change TREE_READONLY VAR_DECLs into their constant initial value
|
|
if they have one.
|
|
|
|
* cplus-parse.y (.set_base_init): Change grammar to not go into
|
|
error mode if a base initializer shows up for a non-member
|
|
function. Otherwise, compiler will push binding levels (in
|
|
`start_function' and `store_parm_decls') which it will not pop,
|
|
leaving us not at global_bindings_p at function end.
|
|
|
|
* cplus-class.c (ideal_candidate): In the event that there is no
|
|
ideal candidate, restore PARMS by moving value from TREE_PURPOSE
|
|
values back into the TREE_VALUE slots.
|
|
|
|
Mon Oct 2 02:28:43 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-lex.c (cons_up_dtor_for_type): Call to `start_method'
|
|
could yield VOID_TYPE_NODE in case of errors. Handle that.
|
|
* cplus-class.c (finish_struct): Caller of `cons_up_dtor_for_type'
|
|
changed.
|
|
|
|
* cplus-decl.c (pushtag): Don't call `pushdecl' on for tags which
|
|
are TREE_NONLOCAL.
|
|
* cplus-class.c (pushclass): Set TREE_NONLOCAL before calling
|
|
`pushtag'.
|
|
|
|
Sun Oct 1 00:05:49 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-tree.h [DECL_VINDEX]: Change definition from being a
|
|
FUNCTION_DECL to being a list of FUNCTION_DECLs, in the event that
|
|
multiple baseclasses define the same virtual function. This only
|
|
affects code where DECL_VINDEX was assumed to be a FUNCTION_DECL,
|
|
namely in cplus-decl.c (grokfndecl) and cplus-class.c
|
|
(add_virtual_function).
|
|
|
|
* cplus-typeck.c (convert_for_initialization): If we are
|
|
converting to an ARRAY_TYPE, don't call `default_conversion' on an
|
|
initializer which is also of ARRAY_TYPE.
|
|
|
|
* cplus-decl.c (finish_decl): If FIELD_DECL is of type ARRAY_TYPE
|
|
that has not yet been laid out, we must go through the code which
|
|
calls `complete_array_type' for TYPE and `layout_decl' for DECL.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): See whether initializer can
|
|
go through a type-conversion operator rather than an X(X&)
|
|
constructor, since wel will save one constructor that way. I.e.,
|
|
trying to go through an X(X&) constructor may lead us to needing
|
|
to go through a type-conversion operator, but the result of that
|
|
conversion must still go through the original X(X&) constructor.
|
|
|
|
* cplus-decl.c (finish_decl): For FUNCTION_DECLs with default
|
|
argument, we build sub-FUNCTION_DECLs to catch calls to this
|
|
function with fewer than the total number of arguments. We set
|
|
TREE_USED of the sub-FUNCTION_DECLs to keep GNU C++ from
|
|
complaining about the function being when compiling with -Wall.
|
|
We also need to set TREE_ASM_WRITTEN and DECL_INITIAL of the
|
|
function to really ensure that GNU C++ does not spuriously
|
|
complain about these sun-FUNCTION_DECLs.
|
|
* cplus-decl.c (grokdeclarator): Set TREE_PUBLIC of after calling
|
|
`grokfndecl' on all paths.
|
|
|
|
* cplus-typeck.c (build_function_call): Set TREE_USED for
|
|
FUNCTION_DECL if TREE_INLINE is zero.
|
|
|
|
* cplus-decl2.c (grok_enum_decls): Move to cplus-decl.c since it
|
|
now needs access to `struct binding_level'.
|
|
* cplus-decl.c (grok_enum_decls): When looking for class-local
|
|
enum tags, warning if we find them in a class binding level other
|
|
than the current one. It probably indicates a parse error in the
|
|
file.
|
|
|
|
* cplus-decl.c (lang_decode_option): Recognize new option
|
|
-Wenum-clash, which gives warnings when enumeral types are
|
|
used in suspect ways, such as assigning from one enumeral
|
|
type to another.
|
|
|
|
* cplus-typeck.c (message_2_types): Was previously called
|
|
`error_2_types'. Now takes argument PFN which is pointer to
|
|
the function which will actually print the message.
|
|
* cplus-typeck.c (convert_for_assignment): Give error for
|
|
passing incompatible enums only if pedantic. Otherwise, give
|
|
warning.
|
|
|
|
* cplus-init.c (finish_base_init): Add argument T which is the
|
|
type for which the base initialization is being finalized. When
|
|
finished initializing fields which come from anonymous unions,
|
|
call `finish_base_init' on that anonymous union, which will unmark
|
|
interesting fields recursively.
|
|
* cplus-decl.c (finish_function): Caller changed.
|
|
|
|
* cplus-method.c (hack_identifier): Permit calls through
|
|
REFERENCE_TYPE fields which overload `operator ()'.
|
|
|
|
* cplus-cvt.c (convert): Remove warning ``assignment to virtual
|
|
aggregate type''.
|
|
|
|
* cplus-decl.c (finish_decl): Make sure to destroy function-local
|
|
static objects if they had been initialized. Set TREE_STATIC bit
|
|
for elements of STATIC_AGGREGATES which are function-local
|
|
objects.
|
|
* cplus-decl2.c (finish_file): Rest of that implementation.
|
|
|
|
Sat Sep 30 20:34:52 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-typeck.c (actualparameterlist): Don't let objects with
|
|
operator= or X(X&) constructors be passing into `...'. If
|
|
PEDANTIC, give error, otherwise, give warning.
|
|
|
|
* cplus-typeck.c (convert_for_assignment): Get tougher on
|
|
conversions to/from enumeral data types.
|
|
|
|
* cplus-typeck.c (build_modify_expr): Make `operator=' an
|
|
inheritable operator.
|
|
|
|
* cplus-decl.c (push_overloaded_decl): Give error message if
|
|
overloaded functions from different language contexts have the
|
|
same type signature.
|
|
|
|
* cplus-cvt.c (build_default_binary_type_conversion): If the types
|
|
are not C++ types, then give error message saying that no type
|
|
conversion operator exists. Call function `typedecl_for_tag' to
|
|
get name for error message.
|
|
* cplus-decl.c (typedecl_for_tag): New function. Return the
|
|
TYPE_DECL (if any) assoicated with TAG.
|
|
|
|
* cplus-class.c (build_functional_cast): Handle case where `A (B)'
|
|
does not mean pass `B' to A's constructor, but rather call
|
|
B.operator A ().
|
|
|
|
* cplus-search.c (get_first_matching_virtual): If argument types
|
|
differ only in their qualifiers, admit a match, but warn the user
|
|
that this match was made.
|
|
|
|
* cplus-lex.c (yyungetc): New function. Give parser routines the
|
|
ability to adjust input tokens if initial lexing was a little bit
|
|
wrong.
|
|
|
|
* cplus-method.c (build_overload_name): Distinguish reference
|
|
types from non-reference types.
|
|
|
|
* cplus-typeck.c (process_init_constructor): Give error messages
|
|
about types of objects which cannot be initialized from an
|
|
initializer list.
|
|
|
|
Wed Sep 27 00:22:16 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-class.c, cplus-init.c (various places): Handle cases that
|
|
fields of struct are really local type declarations.
|
|
|
|
* cplus-decl2.c (grokclassfn): Added new parameter CTYPE, in order
|
|
to remove dependence on class name-class type equivalence. This
|
|
was done for exception handling.
|
|
* cplus-decl.c, cplus-init.c, cplus-except.c: All callers changed.
|
|
* cplus-lex.c (cons_up_dtor_for_type): Added parameter NAME, for
|
|
same reason.
|
|
* cplus-class.c (finish_struct): Caller changed.
|
|
|
|
* cplus-decl.c (duplicate_decls): If OLDDECL's type must change,
|
|
remove OLDDECL from STATIC_AGGREGATES if it was there.
|
|
* cplus-decl2.c (finish_file): Handle VARS being ERROR_MARK_NODE.
|
|
|
|
* cplus-class.c (build_method_call): When calling `build_new',
|
|
pass BASETYPE, not NAME, as the thing to be new'd.
|
|
|
|
* cplus-parse.y (raise_identifiers): Permit qualified names, i.e.,
|
|
`raises List::NotFound'.
|
|
* cplus-decl.c (grokdeclarator): Handle nested exception scopes.
|
|
* cplus-except.c (finish_exception_decl): Ditto.
|
|
* cplus-class.c (build_method_call): Ditto.
|
|
|
|
* cplus-except.c (init_exception_processing): Build in `setjmp'
|
|
and `longjmp'.
|
|
|
|
* cplus-except.c (expand_cplus_{start,end}_exception): If the
|
|
exception object has elements which need cleanpus, call those
|
|
cleanups after handling the exception.
|
|
|
|
* cplus-except.c (finish_exception_decl): Set TYPE_HAS_CONSTRUCTOR
|
|
bit, since call to `grokdeclarator' is subverted.
|
|
|
|
* cplus-except.c (init_exception_processing): Size of `handler'
|
|
field in built-in `ExceptionHandler' type was too big by one.
|
|
|
|
* cplus-init.c (build_delete): Don't call non-virtual destructor
|
|
with first argument of zero.
|
|
|
|
* cplus-parse.y (except_stmts): Handle default exception as last
|
|
exception (so that fall-through does the right thing). Also, give
|
|
error message if multiple `default' clauses appear within an
|
|
`except_stmt'.
|
|
|
|
* cplus-decl.c (finish_decl): If a variable needs a cleanup, pass
|
|
the cleanup to `expand_decl', whether or not that variable has RTL
|
|
or not.
|
|
* cplus-except.c (expand_start_try): Call `finish_decl' instead of
|
|
`expand_aggr_init' to initialize the exception handler for the
|
|
try. Otherwise, the exception handler's destructor will not be
|
|
called at the end of the try.
|
|
|
|
* cplus-decl.c (store_parm_decls): Don't call `__main' from `main'
|
|
until after the parameters have been dealt with.
|
|
|
|
Tue Sep 26 09:41:29 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-parse.y (stmt): Deal with case of TRY statement without
|
|
corresponding EXCEPT clause.
|
|
|
|
* cplus-decl.c (duplicate_decls): Don't call `compexcepttypes'
|
|
until after calling `commontype', lest default parameters cause
|
|
identical exception lists to look different.
|
|
|
|
* cplus-except.c (end_exception_decl): New function clears
|
|
exception declaration state.
|
|
* cplus-parse.y (datadef): Call end_exception_decl when we are at
|
|
the end of a declaration which could be an exception declaration.
|
|
|
|
* cplus-class.c (modify_vtable_entry): Reenable stubbed out code
|
|
which is used when baseclass is virtual.
|
|
* cplus-class.c (finish_struct): When base class is virtual, check
|
|
CLASSTYPE_VBASECLASSES using `value_member' instead of
|
|
CLASSTYPE_ASSOC using `assoc_value'.
|
|
|
|
* dbxout.c (dbxout_tags): Ensure that fully output types have
|
|
their typedefs output as well. Needed to support -fminimal-debug.
|
|
|
|
Sun Sep 24 11:22:41 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-method.c (report_type_mismatch): Don't tweak I if the
|
|
function was FUNCTION_TYPE. Let TTF and TTA be advanced according
|
|
to CP->U.BAD_ARG only.
|
|
|
|
* expr.c (expand_expr): PROTECT argument missing in call to
|
|
`expand_delete'.
|
|
* cplus-init.c (build_delete): Call `convert_force' instead of
|
|
`convert' if PROTECT is 0.
|
|
|
|
* cplus-typeck2.c (digest_init): When initializing a RECORD_TYPE
|
|
object, call `convert_for_initialization' as a last resort.
|
|
|
|
* cplus-tree.c (build_exception_variant): Used TREE_CHAIN for look
|
|
when should have used TYPE_NEXT_VARIANT.
|
|
|
|
* cplus-decl.c ({start,finish}_decl): Handle decls which are
|
|
CLASSTYPE_DECLARED_EXCEPTION. For `start_decl', nothing needs to
|
|
be done. For `finish_decl', call `finish_exception_decl'.
|
|
|
|
* cplus-except.c (finish_exception): When user defines an
|
|
exception, make the compiler generate that exception's constructor
|
|
automatically.
|
|
|
|
* cplus-typeck.c (build_binary_op_nodefault): Associate
|
|
(((a && b) && c) && d) to ((a && b) && (c && d)) to get better
|
|
merging of component references when possible.
|
|
* cplus-typeck2.c (merge_component_comparisons): Permit
|
|
non-contiguous bitfield tests if bitfields are comparisons against
|
|
integers.
|
|
|
|
* cplus-tree.c (layout_basetypes): Give each basetype the
|
|
alignment it wants.
|
|
|
|
* cplus-lex.c (yylex): Recognize >?= and <?= operators (like +=
|
|
for min and max operators).
|
|
|
|
* cplus-decl.c (grokdeclarator): Set TREE_PUBLIC bit of
|
|
FUNCTION_DECLs in FIELD_CONTEXT if they are !INLINEP.
|
|
|
|
* cplus-decl.c (finish_function): Don't pay attention to
|
|
`current_function_returns_null' when compiling constructors.
|
|
|
|
Sat Sep 23 00:03:52 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* stmt.c (assign_parms): Take care of case where parm arrives on
|
|
the stack, but `__builtin_saveregs' might be called. In that
|
|
case, get bits from stack into registers, so that
|
|
`__builtin_saveregs' will not overwrite with garbage.
|
|
* expr.c (expand_builtin): Modify expansion of BUILT_IN_SAVEREGS
|
|
to protect stack args that need protecting.
|
|
|
|
* cplus-decl.c (grokdeclarator): Never build a METHOD_TYPE if
|
|
CTYPE is NULL_TREE. Was doing that when declaration of illegal
|
|
construct ``virtual friend'' was parsed.
|
|
|
|
* cplus-parse.y (do_array:): Don't try to call `build_array_ref'
|
|
if $3 is ERROR_MARK_NODE (cuts down on spurious error messages).
|
|
|
|
* cplus-decl.c (grokfndecl): Move setting of DECL_VIRTUAL_P bit to
|
|
after we know whether the function is virtual. Remove setting
|
|
CLASSTYPE_VSIZE. This will be set more accurately by
|
|
`finish_struct'.
|
|
|
|
Fri Sep 22 15:36:32 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-cvt.c (convert_to_pointer): PATH was reversed for
|
|
computing nested virtual base accesses.
|
|
|
|
* cplus-except.c (finish_exception): Call POPCLASS at end.
|
|
|
|
* cplus-class.c (build_field_call): New function containing code
|
|
broken out of `build_method_call'. Extended to grok calls through
|
|
fields of exception objects which overload `operator()()', or are
|
|
otherwise callable.
|
|
* cplus-class.c (build_method_call): Now about 100 lines shorter.
|
|
|
|
* cplus-decl.c (grokdeclarator): Take new argument RAISES
|
|
specifying the exceptions that a function will raise.
|
|
* cplus-decl.c (grokfield): Implement RAISES semantics by passing
|
|
them to `grokdeclarator'.
|
|
|
|
* cplus-decl.c (grok{fn,var}decl): Two new functions containing
|
|
code broken out of `grokdeclarator'.
|
|
* cplus-decl.c (grokdeclarator): Now about 250 lines shorter.
|
|
|
|
Thu Sep 21 16:51:11 1989 Michael Tiemann (tiemann at arkesden)
|
|
|
|
* cplus-search.c (get_vbase_types): Sort was totally broken.
|
|
Completely rewritten.
|
|
|
|
Wed Sep 20 00:47:36 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl2.c (finish_file): Change !defined(SDB_DEBUGGING_INFO)
|
|
to defined(DBX_DEBUGGING_INFO).
|
|
|
|
* cplus-class.c (finish_struct): Argument to `alloca' was off by
|
|
9.
|
|
|
|
* cplus-init.c (build_new): If type requires alignment >
|
|
BITS_PER_WORD (which is what ``__builtin_new'' is supposed to
|
|
give), then get more space and round manually.
|
|
|
|
Tue Sep 19 03:08:58 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl.c (finish_decl): Don't call `comptypes' if INIT is
|
|
error_mark_node.
|
|
|
|
* cplus-cvt.c (convert_to_reference): Set TREE_VOLATILE bit for
|
|
assignment from one reference to another (for
|
|
build_compound_expr).
|
|
|
|
* cplus-decl2.c (finish_file): If we are compiling on Suns, bind
|
|
local label ``_fini'' to static file cleanup function and
|
|
``_init'' to static file initialization function. STUBBED OUT FOR
|
|
NOW.
|
|
|
|
* cplus-parse.y: Put `type_quals' in 3rd operand position of a
|
|
CALL_EXPR. Interface to `start_function', `start_method'
|
|
and `grokfield' changed.
|
|
* cplus-decl.c (grokdeclarator): Get QUALS from
|
|
TREE_OPERAND (CALL_EXPR, 2). [n.b.: First operand is
|
|
TREE_OPERAND (CALL_EXPR, 0)].
|
|
|
|
* cplus-tree.h (TYPE_RAISES_EXCEPTIONS): For FUNCTION_TYPE and
|
|
METHOD_TYPE, a list of the exceptions that may be raised.
|
|
* cplus-decl.c (duplicate_decls): Remove assumption that
|
|
TYPE_LANG_SPECIFIC implies that type IS_AGGR_TYPE.
|
|
|
|
Mon Sep 18 14:08:02 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-class.c (add_virtual_function): If WRITE_VIRTUALS == 2,
|
|
only set the TREE_ADDRESSABLE bit on a virtual function if the
|
|
virtual function table is actually being output in this file.
|
|
* cplus-decl.c (grokdeclarator): If WRITE_VIRTUALS == 2, make
|
|
inline virtual functions TREE_PUBLIC if we are writing out this
|
|
virtual function's virtual function table.
|
|
* cplus-lex.c (reinit_parse_for_method): Don't clobber the above
|
|
setting of TREE_PUBLIC for virtual functions.
|
|
|
|
* cplus-lex.c: Process inline functions in declaration order.
|
|
|
|
Sun Sep 17 01:46:14 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-declc. (grokdeclarator,start_method,start_function): Merge
|
|
``extern inline'' change.
|
|
|
|
* cplus-typeck2.c (merge_component_comparisons): New function.
|
|
Optimizes operations on contiguous component references provided
|
|
that operations and alignments permit.
|
|
* cplus-typeck2.c (make_merged_ref): Subroutine of above function
|
|
to actually get the combined references.
|
|
|
|
* cplus-typeck2.c: New file. Contains error-reporting
|
|
functionality from cplus-typeck.c, and other functionality which
|
|
could be easily moved out.
|
|
|
|
* cplus-typeck.c (unary_complex_lvalue): Must test against
|
|
{FUNCTION,METHOD,OFFSET}_TYPE before testing whether ARG is a
|
|
MEMBER_REF. If the former holds, then we have an expression like
|
|
X::Y. In the latter case, we have an expression like (X->*Y).
|
|
|
|
Sat Sep 16 11:31:21 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* toplev.c (main): Recognize `+' options again.
|
|
|
|
* cplus-decl.c (lang_decode_option): Implement `+e2' option, which
|
|
writes out only virtual function tables specified in #pragma
|
|
vtable.
|
|
* cplus-decl2.c (finish_file): Implement semantics of `+e2'
|
|
option.
|
|
* cplus-lex.c (yylex): Recognize `#pragma vtable'.
|
|
|
|
* cplus-decl2.c (finish_file): Charge time used against
|
|
VARCONST_TIME, not PARSE_TIME.
|
|
|
|
Thu Sep 14 18:04:10 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-init.c (build_new): If FLAG_THIS_IS_VARIABLE is non-zero,
|
|
then generate call to constructor with zero as first argument.
|
|
Otherwise, use `expand_aggr_init' to initialize the storage
|
|
returned from whatever storage allocator was called.
|
|
Initialization of virtual baseclasses simplified. Memory
|
|
management made more complex (though more general) because we may
|
|
have `new' expressions not being evaluated until `finish_file' is
|
|
called.
|
|
* cplus-decl2.c (finish_file): Handle a `new' expreesion at top
|
|
level.
|
|
|
|
* cplus-decl.c (finish_function): Change call from `build_x_new'
|
|
to `build_new'.
|
|
* cplus-init.c (build_x_new): Deleted.
|
|
|
|
* cplus-init.c (build_new): Give error if arguments are given to a
|
|
`new' expression for which no constructor is defined.
|
|
|
|
* cplus-decl.c (decode_lang_option): Use option table from
|
|
toplev.c to decode -f options.
|
|
|
|
* cplus-method.c (flush_repeats,build_overload_name): Change
|
|
naming convention to avoid ambiguous names if type index or number
|
|
of repeats is more than nine.
|
|
|
|
* cplus-except.c (init_exception_processing): Use <setjmp.h> to
|
|
find length of setjmp buffer.
|
|
|
|
Wed Sep 13 05:32:50 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl.c (start_method): Set TREE_INLINE bit if
|
|
FLAG_DEFAULT_INLINE is nonzero.
|
|
* cplus-decl.c (lang_decode_option): Recognize -fdefault-inline.
|
|
|
|
* cplus-init.c (do_friend): Call `pushdecl_top_level' instead of
|
|
`pushdecl'.
|
|
|
|
* cplus-decl.c (start_method): Only need to copy node if it is not
|
|
a friend.
|
|
* cplus-decl.c (finish_method): In that case, return
|
|
VOID_TYPE_NODE if the method was really a friend, but save it to
|
|
CLASSTYPE_INLINE_FRIENDS so it can be processed properly later.
|
|
It would be nice to have an obstack for this list so it could be
|
|
freed at the end of this class's processing.
|
|
|
|
Tue Sep 12 05:22:03 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl.c (start_function): Make C++ FUNCTION_DECL inherit
|
|
DECL_ASSEMBLER_NAME from old C FUNCTION_DECL if their types are
|
|
identical. This makes C<->C++ calls *much* easier to deal with.
|
|
|
|
* cplus-decl.c (xref_tag): Don't set CLASSTYPE_DECLARED_CLASS bit
|
|
if REF is CURRENT_CLASS_TYPE (??? or on the CURRENT_CLASS_STACK).
|
|
|
|
* cplus-search.c (lookup_field_1): Give the user the virtual
|
|
function table field if the name is `_vptr'.
|
|
* cplus-decl2.c (grokfield): Don't let user declare anything with
|
|
that name.
|
|
|
|
* cplus-cvt.c (build_type_conversion): If we are trying to convert
|
|
to type `void*' and no conversion to ptr_type_node exists, but a
|
|
some other pointer conversion for TYPE exists, then convert to
|
|
that pointer type, unless there is more than one such conversion,
|
|
in which case return ERROR_MARK_NODE. The caller will emit an
|
|
error message in that case. All callers changed.
|
|
* cplus-cvt.c (convert_to_{integer,real,pointer}): Removed `saving
|
|
throw' case which would try converting aggregate to a default type
|
|
if requested conversion did not succeed. `build_type_conversion'
|
|
knows how to perform such `saving throws'.
|
|
* cplus-tree.h (lang_type): New field `ptr_type_conversion'.
|
|
* cplus-decl.c (grokdeclarator): Record whether a type has a
|
|
type conversion operator here.
|
|
* cplus-class.c (finish_struct): Set up `ptr_type_conversion'.
|
|
Also, don't need to trudge through all methods to find out there
|
|
are no type conversion methods.
|
|
|
|
Mon Sep 11 10:45:01 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-class.c (finish_struct): If we must cons up a destructor
|
|
for a type, and METHOD_VEC was 0, set TREE_VEC_LENGTH (METHOD_VEC)
|
|
to 1 after allocating METHOD_VEC.
|
|
|
|
* cplus-class.c (finish_struct): Finish processing METHOD_VEC
|
|
before making other calls out which may call `hash_tree_chain'.
|
|
|
|
* cplus-class.c (finish_struct): Add BASE_LAYOUT_DECL to eliminate
|
|
need for callback in stor-layout.c.
|
|
|
|
* cplus-typeck.c (build_binary_op): Special case situation where
|
|
we compare ARG1 with INTEGER_ZERO_NODE and ARG1 is of aggregate
|
|
type. This is what comes from `truthvalue_conversion'.
|
|
|
|
* cplus-cvt.c (build_type_conversion): New argument CODE says for
|
|
what purpose the conversion is taking place. Important ones are
|
|
truthvalue operations, which permit us to convert to different
|
|
types then the ones we asked for. All callers changed.
|
|
* cplus-cvt.c (build_default_{binary,unary}_type_conversion): Same
|
|
change. All callers changed.
|
|
|
|
* cplus-class.c (finish_{base_}struct): Set
|
|
TYPE_NEEDS_CONSTRUCTING bits when basetype or member type needs
|
|
constructing.
|
|
|
|
* cplus-search.c (compute_visibility): Use TYPE_MAIN_VARIANT to
|
|
see if field is public member of private baseclass.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): When bad arguments were
|
|
passed to constructors for base initialization, only half the
|
|
error message would appear.
|
|
|
|
* Makefile: Remove dependencies on unexec.c and unex-addr.c.
|
|
|
|
* cplus-decl.c (push_overloaded_decl): Can't use `value_member' to
|
|
find previously declared function. Use DECL_NAME of function
|
|
instead, since that must be unique (as a type signature/name
|
|
combination).
|
|
|
|
* cplus-lex.c (yylex): typo in assert macro.
|
|
* cplus-cvt.c (convert_to_nonzero_pointer): Ditto
|
|
|
|
* All GNU C++ files: implement initialized constant fields. Make
|
|
them non-static, non-addressable VAR_DECLs.
|
|
|
|
Sun Sep 10 09:19:22 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-method.c (build_opfncall): Remove METHOD_REF case.
|
|
* tree.def: Remove definition of METHOD_REF.
|
|
|
|
* cplus-decl.c (finish_decl): If a static member needs
|
|
constructing, but it does not have an initializer, make it
|
|
TREE_EXTERNAL.
|
|
* cplus-decl2.c (grokfield): Set DECL_IN_AGGR_P before calling
|
|
`finish_decl' for VAR_DECLs.
|
|
|
|
* cplus-parse.y (forhead.2): New rule to keep GNU C++ gives better
|
|
error handling when multiple variables are declared in the first
|
|
part of a `for' stmt.
|
|
|
|
* cplus-lex.c (finish_method): Handle case when `start_method'
|
|
returns VOID_TYPE_NODE (two definitions of the same method in the
|
|
same class.
|
|
|
|
* cplus-decl.c (grok_op_properties): Make static operators (other
|
|
than new and delete) trigger error messages. If operator new or
|
|
delete has no arguments (due to syntax errors), rebuild their
|
|
types. They have the right names, because `build_operator_fnname'
|
|
knows how to do that.
|
|
|
|
* stor-layout.c (make_{un}signed_type): Cache size nodes for
|
|
pointers, functions, and methods.
|
|
* stor-layout.c (layout_type): Use cached types.
|
|
|
|
* cplus-decl{2}.c: Use `hash_tree_chain' instead of `tree_cons'
|
|
where possible.
|
|
|
|
* cplus-decl.c (expand_static_init): If variable has already been
|
|
initialized, give complaint, but don't store the initializer.
|
|
That way we don't have to preserve it on the temporary obstack.
|
|
|
|
* cplus-parse.y (identifier_or_opname): Accept new C++ destructor
|
|
syntax, which is effectively "scoped_identifier '~' identifier".
|
|
* cplus-class.c (build_scoped_method_call): Accept calls using new
|
|
C++ destructor syntax here.
|
|
* cplus-class.c (build_method_call): Reject calls through here
|
|
which don't use a leading `scoped_identifier'.
|
|
|
|
* cplus-init.c (build_new): Don't permit arrays of `void'. Better
|
|
error message emitted for newing `void'.
|
|
|
|
* cplus-typeck.c (build_conditional_expr): Don't call
|
|
`default_conversion' on the arms of the conditional if both are of
|
|
the same enumeral type. Otherwise, if EXTRA_WARNINGS, give
|
|
warning if enumeral type appears in either (or both) arm(s) of the
|
|
conditional.
|
|
|
|
* cplus-cvt.c (build_type_conversion): Don't convert from `int' to
|
|
`void*'. Don't convert a `void*' to an `int'.
|
|
|
|
* cplus-decl.c (xref_tag): If we get an old reference to a C
|
|
struct name, and we are in C++ langauge context, give it a
|
|
TYPE_DECL.
|
|
|
|
* cplus-class.c (build_method_call): Don't call
|
|
`default_conversion' on MEMBER_REFs because they might be enums.
|
|
Instead, call `resolve_member_ref', and then if the type is
|
|
something we would rather convert before calling
|
|
compute_conversion_costs, convert that.
|
|
|
|
* cplus-init.c: Set TREE_VOLATILE bit after all
|
|
``build (CALL_EXPR, ...)'' calls.
|
|
|
|
* cplus-init.c (expand_vec_init): If at global binding level,
|
|
return a TREE_VEC which contains the initialization parameters for
|
|
the vector. `expand_vec_init' is no longer static.
|
|
* cplus-decl.c (finish_decl): Handle INIT being result of
|
|
`expand_vec_init' at top-level.
|
|
* cplus-decl2.c (finish_file): Ditto.
|
|
|
|
Sat Sep 9 12:44:48 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-class.c (finish_struct): Move error message about static
|
|
members in unions from stor-layout.c to here.
|
|
|
|
* varasm.c, stor-layout.c: Merged with GCC.
|
|
* cplus-class.c (finish_struct): Use special FIELD_DECL in
|
|
TYPE_FIELDS of T before calling `layout_type' to have effect of
|
|
passing basetype layout information to `layout_record'.
|
|
|
|
* cplus-typeck.c (build_c_cast): Typo in call to
|
|
cleanup_after_call.
|
|
|
|
Fri Sep 8 11:16:01 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* All GNU C++ files: replaced calls to `abort' with assertion
|
|
macros where appropriate. Also removed some unneccessary tests
|
|
against ERROR_MARK_NODE in various function calls.
|
|
|
|
* cplus-lex.c (check_newline): Changed to take NEXTCHAR into
|
|
account.
|
|
|
|
Thu Sep 7 06:15:56 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl.c (store_parm_decls): Change where
|
|
DECL_REFERENCE_SLOT is initialized. Eliminate a second loop
|
|
through the parms.
|
|
|
|
* cplus-method.c (hack_identifier): Don't need to test against
|
|
FUNCTION_DECL before testing if the TREE_TYPE is REFERENCE_TYPE.
|
|
|
|
* cplus-lex.c (yylex): If reading `0' or `1', return
|
|
INTEGER_ZERO_NODE or INTEGER_ONE_NODE respectively.
|
|
* cplus-decl.c (build_enumerator): If we got one of these two
|
|
as a value, make a copy.
|
|
|
|
* tree.c,cplus-lex.c,cplus-class.c,cplus-search.c
|
|
[GATHER_STATISTICS]: Now only gather statistics if this macro is
|
|
defined.
|
|
|
|
* tree.c (make_node,build_int_2,tree_cons,build_tree_list): Merge
|
|
Bryan Boreham's ``deluxe'' memory profiling code.
|
|
|
|
* cplus-decl.c (finish_decl): Only complain about uninitialized
|
|
refs and consts if there is no constructor for the type. If there
|
|
is a constructor, then that constructor should say whether it did
|
|
not initializer certain fields or not.
|
|
|
|
* cplus-init.c (expand_aggr_init): When initializing, nothing is
|
|
`const'.
|
|
|
|
* cplus-decl.c (store_parm_decls): No need to call
|
|
expand_decl_init on a PARM_DECL. In fact, now it is wrong.
|
|
|
|
* tree.h: rearranged tree_decl layout and defined
|
|
tree_function_decl type for FUNCTION_DECLs. Now space
|
|
requirements for FUNCTION_DECLs do not impose on other kinds of
|
|
_DECL nodes. Also, PARM_DECL nodes use less than a full decl
|
|
node's worth of space.
|
|
* toplev.c (rest_of_decl_compilation): Don't permit ASMSPEC to
|
|
appliy to PARM_DECL nodes.
|
|
* varasm.c (make_decl_rtl): Abort if called for a PARM_DECL node.
|
|
* print-tree.c (dump): PARM_DECL nodes are not full.
|
|
FUNCTION_DECL nodes have more fields then regular _DECLs now.
|
|
* tree.c (make_node): Use TREE_CODE_LENGTH when allocating _DECL
|
|
nodes. Also, don't set DECL_SOURCE_* for PARM_DECL nodes.
|
|
Instead, set their DECL_CONTEXT to CURRENT_FUNCTION_DECL.
|
|
* tree.c (build_decl): Don't set DECL_ASSEMBLER_NAME for PARM_DECL
|
|
nodes.
|
|
* cplus-decl.c (start_decl): Don't not push DECL if DECL is a
|
|
PARM_DECL.
|
|
|
|
* cplus-lex.c (yylex): Remove tests about whether we *really* saw
|
|
a keyword or not. Instead, use `init_lex' to do most of the work
|
|
for us (since lang_c's reserved word set is a subset of
|
|
lang_cplusplus).
|
|
|
|
* cplus-decl.c,cplus-decl2.c,cplus-typeck.c,cplus-class.c,
|
|
cplus-lex.c, cplus-method.c: change tests of the form
|
|
(TREE_VALUE (t) == void_type_node) to (t == void_list_node).
|
|
|
|
* cplus-decl2.c (grokopexpr): Added argument CTYPE to help
|
|
distinguish whether operators NEW and DELETE belong to a class, or
|
|
are the global operators NEW and DELETE.
|
|
* cplus-decl.c (grokdeclarator): Caller changed.
|
|
* cplus-method.c (hack_operator): Caller changed.
|
|
|
|
Wed Sep 6 10:29:45 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* dbxout.c (dbxout_type): Handle static member functions.
|
|
|
|
* cplus-typeck.c (c_expand_return): Change test from
|
|
TYPE_NEEDS_CONSTRUCTING to TYPE_NEEDS_CONSTRUCTOR to see whether
|
|
`expand_aggr_init' must be called.
|
|
|
|
* cplus-decl2.c (grokfield): Use `digest_init' to digest
|
|
CONSTRUCTOR initializers of fields.
|
|
|
|
* cplus-decl.c (grokdeclarator): Permit ARRAY_TYPE field decls to
|
|
get their types from their initializer (if they were incomplete).
|
|
|
|
* cplus-lex.c (build_operator_fnname): If there is more than one
|
|
parameter to NEW_EXPR, then it is `__user_new'.
|
|
|
|
* cplus-decl.c (store_parm_decls): Remove code to deal with case
|
|
that function was declared without prototypes. It is never
|
|
executed.
|
|
|
|
* cplus-typeck.c (unary_complex_lvalue): Handle (x->*y) as an
|
|
lvalue.
|
|
|
|
* cplus-decl.c (start_decl): Put in check that temporary obstack
|
|
starts out empty when we start parsing an initializer.
|
|
* cplus-decl.c (expand_static_init): If the initializer was read
|
|
into the temporary obstack, preserve all space that it used. I
|
|
don't think it is safe to always read the initializer into the
|
|
permanent_obstack and then free the space if it doesn't look
|
|
interesting, because types may be created dynamically as a result
|
|
of reading it in (such as array types), and we don't want them to
|
|
get freed.
|
|
|
|
* cplus-decl.c (finish_decl): Don't set DECL_ASSEMBLER_NAME of the
|
|
decl to ASMSPEC if ASMSPEC is 0.
|
|
|
|
* cplus-decl.c (finish_function): Set named_label_uses to
|
|
NULL_TREE at end of function.
|
|
|
|
Tue Sep 5 05:24:18 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-except.c: New file. Implements exception handling scheme
|
|
designed by Michael Powell.
|
|
|
|
* cplus-method.c (build_overload_name): Overload constructor names
|
|
as '__' instead of whatever their original name was.
|
|
* cplus-method.c (build_decl_overload): Distinguish constructors
|
|
from other kinds of member functions.
|
|
* cplus-decl2.c (grokclassfn): Call changed to
|
|
`build_decl_overload' to take this into account.
|
|
|
|
* cplus-decl.c (duplicate_decls): Don't crash if NEWDECL is a
|
|
VAR_DECL, and there is an old VAR_DECL on the chain. Happens for
|
|
strange parse errors.
|
|
|
|
Mon Sep 4 01:36:07 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-decl2.c: New file. Contains functions which used to be
|
|
defined in cplus-decl.c, but could be easily broken out. Also
|
|
moved some functions out of cplus-tree.c which did not really
|
|
belong there, but were put there to make compilation less painful.
|
|
|
|
* cplus-class.c (build_method_call): Use ERR_NAME in more places
|
|
when printing error messages.
|
|
|
|
* cplus-decl.c (grokdeclarator): Special case NEW_EXPR and
|
|
DELETE_EXPR when grokking an OP_IDENTIFIER. Make these guys
|
|
static member functions. Callers in cplus-init.c changed.
|
|
* cplus-tree.c (coerce_new_type,coerce_delete_type): Force the
|
|
type of `operator new' and `operator delete' to wind up with the
|
|
right types.
|
|
* cplus-lex.c (build_operator_fnname): Handle `operator new' and
|
|
`operator delete' correctly, warning when the wrong number of
|
|
parameters show up.
|
|
|
|
* expr.c (expand_expr): Add NEW_EXPR to the list of tree codes
|
|
for which INIT_EXPR and MODIFY_EXPR don't need to deal with
|
|
noncopied_parts.
|
|
|
|
* cplus-class.c (finish_struct): Initialize TREE_PURPOSE of
|
|
TYPE_NONCOPIED_PARTS to the virtual function table for the type.
|
|
|
|
* cplus-cvt.c (build_type_conversion_1): Compiler was getting into
|
|
infinite recursion when asked to convert something from its own
|
|
type to its own type.
|
|
|
|
* cplus-parse.y: Added RERAISE statement.
|
|
* cplus-lex.c: Added __reraise keyword.
|
|
|
|
* cplus-cvt.c (build_type_conversion): Build type conversions to
|
|
type variants (i.e., given `operator char * ()', convert to a
|
|
`const char *').
|
|
|
|
* dbxout.c (dbxout_tags): Callback to language-specific files to
|
|
see whether a type should actually be output.
|
|
* dbxout.c (dbxout_symbol): Same change.
|
|
* cplus-tree.c (lang_output_debug_info): New function.
|
|
* cplus-decl.c (finish_function): Memoize information for
|
|
lang_output_debug_info.
|
|
|
|
* Merged latest changes from Bryan Boreham for incremental
|
|
compilation via dumping.
|
|
|
|
* cplus-parse.y: Recognize `::new' and `::delete'.
|
|
* cplus-init.c (build_new): Handle `::new' by new interpretation
|
|
of USER_PARMS. Only callers in cplus-parse.y needed changing.
|
|
* cplus-init.c (build_{x_}delete): Handle `::delete' by accepting
|
|
new argument USE_GLOBAL_DELETE. All callers changed.
|
|
|
|
Sun Sep 3 12:42:38 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* expr.c (expand_cleanups_to): New function.
|
|
* cplus-init.c (expand_cplus_expr_stmt): Call it after all is said
|
|
and done.
|
|
|
|
* expr.c (expand_expr): When encountering a NEW_EXPR, it is
|
|
possible that the NEW_EXPR did not know (when it was built) what
|
|
its cleanup needed to be. If its cleanup is 0, try building one
|
|
if a new temporary was built for it.
|
|
|
|
* cplus-decl.c (duplicate_decls): Warn if function type qualifiers
|
|
don't match only if PEDANTIC (following change made by rms).
|
|
|
|
* cplus-typeck.c (build_function_call): If pedantic, don't permit
|
|
`main' to be called.
|
|
|
|
* cplus-typeck.c (convert_for_assignment): Don't let ints
|
|
convert to enums.
|
|
|
|
* cplus-decl.c (start_function): Ensure that `main' is
|
|
always declared to return an integer type.
|
|
* cplus-decl.c (finish_function): Make it so that `main' always
|
|
returns 0 by default.
|
|
|
|
* cplus-decl.c (grokdeclarator): Make it now an error to specify
|
|
return types for constructors and destructors.
|
|
|
|
* cplus-typeck.c (comp_target_{parms,types}): Loosen up to permit
|
|
contravariance violations, though not without warning.
|
|
|
|
* cplus-method.c (build_overload_name): Change from old
|
|
overloading scheme to one more or less compatible with type-safe
|
|
linkage scheme proposed in Stroustrup's 1988 USENIX paper.
|
|
|
|
Sat Sep 2 09:16:01 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-typeck.c (convert_for_initialization): Permit
|
|
initialization of reference from incomplete type: that type will
|
|
be converted to REFERENCE_TYPE, and that is just as good as a
|
|
pointer to incomplete type.
|
|
|
|
* cplus-decl.c (finish_decl): Handle case of static reference
|
|
initialized from non-constant initializer. Break out code to
|
|
initialize static variables as function `expand_static_init'.
|
|
|
|
* cplus-decl.c (finish_decl): Don't call constructors on external
|
|
variables.
|
|
|
|
* integrate.c (copy_for_inline): Canonicalize PLUS expressions so
|
|
that CONST_INTs appear on the right, and `FRAME_POINTER_RTX'
|
|
and/or `ARG_POINTER_RTX' on the left.
|
|
* integrate.c (copy_rtx_and_substitute): Take advantage of this
|
|
fact and test fewer things while integrating.
|
|
|
|
* cplus-typeck.c (c_expand_return): Try to get away with not
|
|
issuing a call to `use_variable' for the DECL_RESULT of the
|
|
function. If that fails, calling it only if
|
|
`any_pending_cleanups' returns nonzero.
|
|
|
|
* cplus-init.c (expand_recursive_init_1): Handle multi-demensional
|
|
arrays which need constructing.
|
|
* cplus-init.c (expand_vec_init): Handle multi-demensional arrays.
|
|
Say sorry if we try to use an explicit initializer in that case,
|
|
however.
|
|
|
|
* cplus-parse.y: Permit the integer zero to be deleted (though who
|
|
would want to?).
|
|
|
|
* varasm.c (make_function_rtl): Replace call to lang_rtl_name with
|
|
use of DECL_ASSEMBLER_NAME.
|
|
* cplus-decl.c (lang_rtl_name): Removed.
|
|
|
|
* cplus-decl.c (grokclassfn): Set DECL_ASSEMBLER_NAME after
|
|
changing DECL_NAME.
|
|
* cplus-init.c (do_friend): Ditto.
|
|
|
|
* cplus-decl.c (start_function): If CURRENT_FUNCTION_DECL is a
|
|
destructor, set up DESTRUCTOR_LABEL.
|
|
* cplus-decl.c (finish_function): If DESTRUCTOR_LABEL is nonzero,
|
|
expand just before calling base destructors.
|
|
* cplus-typeck.c (c_expand_return): If DESTRUCTOR_LABEL is
|
|
nonzero, jump there instead of just expanding the return.
|
|
|
|
* collect.c (process): Change from
|
|
(andrew%frip.wv.tek.com@relay.cs.net) to skip auxiliary entries.
|
|
|
|
* All GNU C++ files merged from 1.35.97+ to 1.35.98.
|
|
|
|
* cplus-decl.c (define_label): If a newly declared variable in the
|
|
label's binding contour will need a cleanup, it must live in a new
|
|
binding contour.
|
|
* cplus-decl.c (define_case_label): New function. Same goes for
|
|
case labels.
|
|
* cplus-parse.y (stmt): Call `define_case_label' for CASE
|
|
statements.
|
|
|
|
* cplus-decl.c (lookup_label): Record in variable NAMED_LABEL_USES
|
|
for each label the variables currently in scope at the use of the
|
|
label.
|
|
* cplus-decl.c (define_label): Give error message if jump to label
|
|
crosses variable initialization in the current scope.
|
|
|
|
* cplus-decl.c (struct binding_level): Change field
|
|
`more_cleanups_ok' from char to bitfield. Added field
|
|
`have_cleanups'. Change other fields to bitfields so that
|
|
`struct binding_level' fits in 7 words, which can be
|
|
malloc'd in total of 32 bytes.
|
|
* cplus-decl.c (PUSH_BINDING_LEVEL,maybe_build_cleanup):
|
|
Initialize and set field `have_cleanups'.
|
|
* cplus-decl.c (expand_label): Set `more_cleanups_ok' to zero when
|
|
we cross a label.
|
|
|
|
* stmt.c (struct stack_block): Added field `initialized_decls_p'
|
|
for blocks which need their decls expanded before used.
|
|
* stmt.c (expand_decl{_init}): Set field initialized_decls_p when
|
|
appropriate.
|
|
|
|
Fri Sep 1 04:29:44 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* Exception handling constructs recognized (but nothing working).
|
|
|
|
* cplus-decl.c (init_decl_processing): Call `set_identifier_size'
|
|
with a length, not a number of bytes.
|
|
|
|
* cplus-class.c (build_class_init_list): Braino.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): Reinitialize virtual base
|
|
class virtual function tables if they are set to wrong values by
|
|
their constructors.
|
|
* cplus-init.c (expand_aggr_init): Initialize virtual base class
|
|
virtual function tables if they are not set any other way.
|
|
|
|
* cplus-class.c (finish_struct): Use CLASSTYPE_VSIZE instead of
|
|
TYPE_VIRTUAL_P to determine whether a particular class has virtual
|
|
functions which belong in its vtable. A type can be
|
|
TYPE_VIRTUAL_P, meaning that *somewhere* it relies on virtual
|
|
functions, but CLASSTYPE_VSIZE could be zero, meaning that it
|
|
itself may not even have a virtual function table pointer.
|
|
* cplus-decl.c (finish_file): Same changes.
|
|
* cplus-decl.c (setup_vtbl_ptr): Same changes.
|
|
* dbxout.c (dbxout_type): Same changes.
|
|
* cplus-tree.c (layout_basetypes): Same changes.
|
|
|
|
* cplus-class.c (finish_base_struct): Return 0 if all virtual
|
|
functions come only from virtual baseclasses. Also, do not put
|
|
into VFIELDS those fields which come from virtual baseclasses.
|
|
* cplus-class.c (modify_vtable_entry): Instead, run through by
|
|
hand the virtual baseclasses whose virtual function tables need to
|
|
be modified. This means really using exactly the right
|
|
associations for both base, context, and derived types.
|
|
* cplus-class.c (prepare_fresh_vtable): Change parameter TYPE to
|
|
CONTEXT_ASSSOC. All callers changed.
|
|
|
|
Thu Aug 31 08:17:45 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-class.c (finish_struct): Test MAX_HAS_VIRTUAL, not
|
|
HAS_VIRTUAL to assign TYPE_VIRTUAL_P (T).
|
|
|
|
* integrate.c (save_for_inline): Add new variable
|
|
PARM_INITIALIZATION which is nonzero during parameter
|
|
initialization (either from the stack or registers).
|
|
* integrate.c (copy_for_inline): Only zero TREE_READONLY of parm
|
|
if PARM_INITIALIZATION is zero.
|
|
* integrate.c (expand_inline_function): Back out Aug 30
|
|
TREE_INLINE change for PARM_DECLs.
|
|
* cplus-decl.c, cplus-typeck.c: Ditto.
|
|
|
|
* cplus-decl.c (finish_decl): Take into account case where static
|
|
variable must be initialized ``by hand''.
|
|
|
|
* cplus-typeck.c (store_init_value): Return VALUE if
|
|
initialization could not be trivially performed for static
|
|
variable. Otherwise return NULL_TREE.
|
|
|
|
* cplus-decl.c (get_temp_name): Add parameter STATICP. All
|
|
callers changed.
|
|
|
|
* integrate.c (copy_rtx_and_substitute): Significantly simplify
|
|
PLUS and MEM case after finding out that code from tList.cc could
|
|
break the complex cases on Sparc. Net effect: maybe more work for
|
|
optimizer in later passes, and maybe more space occupied by inline
|
|
insns during compilation.
|
|
|
|
* expr.c (store_one_arg): Add test to see if we can avoid calling
|
|
convert_units if possible.
|
|
|
|
Wed Aug 30 04:01:15 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* toplev.c (main): Change +e[01] to -f+e[01], and move to
|
|
lang_decode_option.
|
|
* cplus-decl.c (lang_decode_option): Incorporate new flags.
|
|
|
|
* integrate.c (copy_rtx_and_substitute): Don't build a SUBREG of a
|
|
CONST_INT.
|
|
|
|
* integrate.c (expand_inline_function): Change test of FORMAL from
|
|
TREE_READONLY to TREE_INLINE.
|
|
* cplus-typeck.c (build_modify_expr,build_unary_op): When
|
|
modifying a PARM_DECL, set TREE_INLINE to 0.
|
|
* cplus-decl.c (store_parm_decls): Set TREE_INLINE of PARM_DECL to
|
|
1.
|
|
|
|
* cplus-decl.c (finish_function): When finishing constructors, if
|
|
simple case holds (no cleanups), just store CURRENT_CLASS_DECL
|
|
into the DECL_RESULT of FNDECL and fall through.
|
|
|
|
* integrate.c (expand_inline_function): Don't emit
|
|
NOTE_INSN_DELETED notes.
|
|
|
|
* cplus-parse.y (compstmt): Only save binding contour information
|
|
if there actually were decls.
|
|
|
|
* cplus-decl.c (finish_file): Argument LINENO was missing in calls
|
|
to finish_function.
|
|
|
|
Tue Aug 29 23:03:17 1989 Michael Tiemann (tiemann at teacake)
|
|
|
|
* cplus-typeck.c (unary_complex_lvalue): Treat INIT_EXPR like
|
|
MODIFY_EXPR. Also, handle WITH_CLEANUP_EXPR case.
|
|
|
|
* expr.c (expand_expr): Brainos in WITH_CLEANUP_EXPR case.
|
|
|
|
* cplus-cvt.c (build_up_reference): Handle case where ARG is a
|
|
WITH_CLEANUP_EXPR.
|
|
|
|
* stmt.c (expand_function_end): *Don't* set REG_FUNCTION_VALUE_P.
|
|
|
|
* tree.def [NEW_EXPR]: Change from 2 arguments to 3. Third
|
|
argument, if non-NULL, is cleanup expression to run after the
|
|
new'd expression is used. All users of NEW_EXPR changed.
|
|
|
|
Sun Aug 27 01:13:09 1989 Michael Tiemann (tiemann at hobbes.ai.mit.edu)
|
|
|
|
* stor-layout.c (layout_basetypes): Move from this file.
|
|
* cplus-tree.c (layout_basetypes): To this one.
|
|
|
|
* make-links.g++ (borrowed_files): typeclass.h is now a
|
|
borrowed file.
|
|
|
|
* cplus-decl.c (cleanup_after_call): New function.
|
|
* cplus-typeck.c (build_compound_expr): Call it if neccesary.
|
|
* cplus-typeck.c (build_c_cast): Ditto.
|
|
* cplus-init.c (expand_cplus_expr_stmt): Ditto.
|
|
* expr.c (expand_call): Remove code to allocate destructable stack
|
|
slot if function return value is not used.
|
|
|
|
* cplus-decl.c (init_decl_processing): `built_in_vec_delete' is
|
|
NOT_BUILT_IN.
|
|
* expr.c (expand_builtin): Don't try to expand EXPAND_VEC_DELETE.
|
|
|
|
* cplus-init.c (build_vec_delete): Build the vector delete here;
|
|
don't make a call to `__builtin_vec_delete'.
|
|
|
|
* expr.c (expand_expr): Merge INIT_EXPR and MODIFY_EXPR.
|
|
* expr.c (init_noncopied_parts): New function.
|
|
|
|
* gcc.c: Merged completely. Use GCC from standard distribution.
|
|
|
|
Sat Aug 26 10:38:14 1989 Michael Tiemann (tiemann at hobbes.ai.mit.edu)
|
|
|
|
* cplus-typeck.c (build_binary_op): Perform type instantiation if
|
|
necessary.
|
|
|
|
* cplus-class.c (instantiate_type,build_instantiated_decl): Change
|
|
"type instantiation" to "overload" in various error messages.
|
|
* cplus-class.c (instantiate_type): Also fix error message to
|
|
report overload resolution failure only if function has more than
|
|
one type signature declared.
|
|
|
|
* cplus-class.c (instantiate_type): Call `mark_addressable' on
|
|
result of instantiating something for an ADDR_EXPR.
|
|
|
|
* 1.35.96 to 1.35.97+ changes:
|
|
* Makefile: Change name of `cplus-parse.tab.*' to `cplus-tab.*'.
|
|
* cplus-lex.c: Change #includes to reflect this.
|
|
* cplus-decl.c: All merged except CURRENT_EXTERN_INLINE.
|
|
* toplev.c: Changes for extern inlines not merged.
|
|
|
|
* cplus-decl.c (finish_file): Reset FNNAME from DECL_NAME of the
|
|
current function, since `start_function' may cause it to change if
|
|
overloaded. Also, push into C language context during the
|
|
generation of file-level initializer/cleanup functions, since we
|
|
don't want the extra-long names that overloading will give us.
|
|
|
|
* cplus-decl.c,cplus-class.c,cplus-search.c: #include "obstack.h"
|
|
instead of "cplus-obstack.h".
|
|
|
|
* gnulib3.c: New file. Provides initialization and cleanup
|
|
services for GNU C++. This should obviate the need for crt0.c.
|
|
* crt1.c: Changed completely for new initialization/cleanup model.
|
|
* cplus-decl.c (store_parm_decls): Put in special hooks to call
|
|
`__main' from `main' for such purposes.
|
|
|
|
Thu Aug 24 02:11:42 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-lex.c (check_newline): Only call unexec #ifndef
|
|
DONT_HAVE_UNEXEC.
|
|
|
|
* cplus-lex.c (reinit_parse_for_method)[USG]: If the buffer given
|
|
to setvbuf is shorter than eight bytes long, setvbuf will (in
|
|
violation of its man page) ignore the buffer and call malloc to
|
|
get a bigger one. Fixed.
|
|
|
|
* cplus-typeck.c (comp_target_types): Permit converting from a T**
|
|
to a T** which has different qualifiers.
|
|
|
|
* gcc.c (collect_spec): Changes for sun386.
|
|
* collect.c: Ditto.
|
|
* config.g++: Ditto.
|
|
|
|
* cplus-parse.y (primary): Handle case where unfound
|
|
identifier comes from base class during class declaration.
|
|
|
|
* cplus-init.c (build_member_ref): Handle uses of class-local
|
|
enums and static members before type is completed.
|
|
|
|
* cplus-decl.c (pushdecl_class_level): Put enums and static
|
|
members into class scope as soon as they are seen.
|
|
* cplus-decl.c (poplevel_class): Make sure to take them out upon
|
|
leaving scope.
|
|
|
|
* cplus-lex.c (build_lang_field_decl): Take new argument CODE to
|
|
say what kind of decl to build.
|
|
* cplus-decl.c,cplus-parse.y: All callers changed.
|
|
* cplus-decl.c (grok_enum_decls): Call `build_lang_field_decl'
|
|
instead of `build_lang_decl'. Saves memory.
|
|
* cplus-decl.c (grokdeclarator): Same change for VAR_DECLs local
|
|
to structs.
|
|
|
|
* cplus-typeck.c (build_modify_expr): Fix logic so that when
|
|
assigning to `this', the error message about not being within a
|
|
constructor or destructor is only emitted at the appropriate time.
|
|
|
|
* cplus-tree.h [OPERATOR_NEW_FORMAT,OPERATOR_DELETE_FORMAT]:
|
|
Define these.
|
|
* cplus-method.c (build_opfncall): Use them.
|
|
|
|
* cplus-tree.h [OPERATOR_MODIFY_FORMAT,OPERATOR_MODIFY_LENGTH,
|
|
OPERATOR_CALL_FORMAT,OPERATOR_CALL_LENGTH,OPERATOR_ARRAY_FORMAT,
|
|
OPERATOR_ARRAY_LENGTH]
|
|
Define these.
|
|
* cplus-decl.c (grok_op_properties): Use them.
|
|
* cplus-init.c (add_friends): Ditto.
|
|
|
|
* cplus-tree.h [VTBL_PTR_TYPE]: Define this.
|
|
* cplus-decl.c (init_decl_processing): Use it.
|
|
|
|
* cplus-tree.h [OPERATOR_METHOD_FORMAT,OPERATOR_METHOD_LENGTH]:
|
|
Define these.
|
|
* cplus-class.c (build_method_call): Use them.
|
|
|
|
* cplus-class.c (compute_conversion_costs): Fix typo which would
|
|
cause error message to be generated for calling a const member
|
|
function with a non-const object.
|
|
|
|
* Aug 24 03:10 g++.xtar.Z on ~ftp/pub
|
|
|
|
* cplus-init.c (build_new): Braino involving -fthis-is-variable
|
|
removed.
|
|
|
|
Wed Aug 23 00:12:29 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (finish_decl): Cannot forever remove READONLY
|
|
attribute from decl needing initialization.
|
|
|
|
* cplus-method.c (report_type_mismatch): Report error if calling
|
|
non-const member function with const object.
|
|
|
|
* cplus-class.c (convert_harshness,build_method_call): Finish
|
|
implementing code to catch calls to non-const member functions
|
|
with const objects.
|
|
|
|
* cplus-class.c (build_method_call): No longer need to get to
|
|
TYPE_MAIN_VARIANT for type information, such as TYPE_NEEDS_....
|
|
|
|
* cplus-class.c (finish_struct): Set flags in all type variants.
|
|
* cplus-parse.y (various places): Ditto.
|
|
|
|
* integrate.c (expand_inline_function): No longer call abort if
|
|
TREE_TYPE (arg) != TREE_TYPE (formal) for BLKmode parameter. This
|
|
can happen when TREE_TYPE (formal) == ERROR_MARK_NODE.
|
|
|
|
Tue Aug 22 09:06:32 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (ideal_candidate): Use `function' member instead
|
|
of `u.field' member of candidates. The former is always properly
|
|
set up, whereas the latter is set to 0 if the function used is a
|
|
non-member function.
|
|
|
|
* cplus-decl.c (groktypefield): Handle case where IDENTIFIER_NODE
|
|
comes in which is not an aggregate type name.
|
|
|
|
* cplus-method.c (hack_operator): Return ERROR_MARK_NODE if
|
|
operator name is missing.
|
|
* cplus-parse.y: Callers changed to deal with this.
|
|
|
|
* cplus-search.c (various places): Most calls to
|
|
`error_with_aggr_type' were wrong, leading to backward error
|
|
messages (such as `member `A' not found for class `memfunc').
|
|
Changed back to call `error' with appropriate parameters.
|
|
|
|
* cplus-search.c (lookup_fnfields): Braino in printing error
|
|
message: TREE_VALUE (entry) is a BASELINK (a TREE_LIST of
|
|
TREE_LISTs), not a TREE_LIST.
|
|
|
|
* cplus-decl.c (grokdeclarator): Handle missing operator name for
|
|
for OP_IDENTIFIER case.
|
|
|
|
* cplus-init.c (finish_base_init): If the vtable installed by the
|
|
constructor was not the right one, fix after call to base
|
|
constructor, before derived initialization.
|
|
|
|
* cplus-decl.c (store_parm_decls): New parm PRESERVE is nonzero if
|
|
we should preserve the data containing the function parameters.
|
|
This is normally done for inline functions, but also needs to be
|
|
done for constructors of classes which use virtual baseclasses.
|
|
* cplus-decl.c (finish_function): Don't set DECL_ARGUMENTS (FNDECL)
|
|
to zero if above condition holds.
|
|
* cplus-decl.c, cplus-parse.y: all callers of store_parm_decls
|
|
modified.
|
|
|
|
* cplus-tree.c (hash_tree_chain): New function. Simplified
|
|
version of hash_tree_cons.
|
|
* cplus-parse.y (declmods): Use `hash_tree_chain' to build up
|
|
lists which are not destroyed during parsing. They can be reused
|
|
throughout the rest of the parse.
|
|
|
|
Mon Aug 21 09:51:47 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-init.c (expand_aggr_init_1): Replace PARM_DECL rtl's with
|
|
actual values to parameters.
|
|
|
|
* cplus-init.c (expand_aggr_vbase_init): Only try initializing
|
|
base classes here if FNDECL is nonzero.
|
|
* cplus-init.c (expand_aggr_init_1): Try initializing them here in
|
|
that case instead.
|
|
|
|
* cplus-decl.c (finish_decl): We can initialize a const& from a
|
|
const int, etc.
|
|
|
|
* cplus-init.c (expand_vec_delete): Only warn about ignored array
|
|
size expressions if EXTRA_WARNINGS.
|
|
|
|
* cplus-init.c (build_new): Don't forget to allocate space for
|
|
vectors.
|
|
|
|
* cplus-init.c (add_friend): If the friend is not of METHOD_TYPE,
|
|
set CTYPE = ERROR_MARK_NODE. This prevents false friend matches
|
|
due to fact that `is_friend' assumes that if CURRENT_CLASS_TYPE ==
|
|
TREE_PURPOSE (friends), that a class-match has occured.
|
|
|
|
* stmt.c (expand_end_bindings): Don't let cleanups affect ({...})
|
|
constructs.
|
|
|
|
* cplus-decl.c (finish_decl): When initializing one reference from
|
|
another, make sure that we wrap the initializer in a SAVE_EXPR if
|
|
it is TREE_VOLATILE.
|
|
|
|
* cplus-class.c (compute_conversion_costs): Check that FORMAL_TYPE
|
|
is not ERROR_MARK_NODE.
|
|
|
|
* tree.h (tree_type): Delete unused field `parse_info'.
|
|
|
|
* cplus-decl.c (setup_vtbl_ptr): Add tests for OPTIMIZE and that
|
|
CURRENT_FUNCTION_DECL is not DECL_STATIC_FUNCTION_P.
|
|
|
|
Sun Aug 20 12:09:30 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c,cplus-typeck.c (various places): Check for
|
|
CONST_DECL in addition to TREE_READONLY VAR_DECLs when needing
|
|
constants for various purposes.
|
|
|
|
Sat Aug 19 12:27:41 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (build_method_call): Handle case where
|
|
INSTANCE_PTR is integer_zerop. This can happen with casts like
|
|
{ return ((Object*)0)->Object::IsA(); }
|
|
|
|
Fri Aug 18 01:14:02 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (build_method_call): Complain about using abstract
|
|
function only if INSTANCE is of known abstract type.
|
|
|
|
* cplus-class.c (add_method): Don't crash if FIELDS is 0.
|
|
|
|
* dbxout.c (dbxout_type): Don't crash if type only defines
|
|
constructors and destructors.
|
|
|
|
* cplus-typeck.c (build_component_ref): If METHOD_VEC is 0, break
|
|
out of loop.
|
|
|
|
* cplus-decl.c (finish_file): Don't abort if INIT is 0.
|
|
|
|
Thu Aug 17 21:55:35 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-parse.y (LC): If the type we get left of a '{'
|
|
!IS_AGGR_TYPE, then make a fake node which can hold our types for
|
|
us.
|
|
|
|
* cplus-init.c (do_friend): Argument missing in call to
|
|
grokclassfn.
|
|
|
|
* cplus-decl.c (poplevel): Only call `expand_end_bindings' if the
|
|
level being popped needed an `expand_start_bindings' to get going.
|
|
This only happens if the level is specifically to hold
|
|
temporaries (i.e., when the KEEP field is < 0).
|
|
|
|
* cplus-decl.c (finish_decl): Emit a sorry message if the _DECL
|
|
needs constructing, and is not at toplevel.
|
|
|
|
* cplus-class.c (build_method_call): Complain about incomplete
|
|
types only if (FLAGS&LOOKUP_COMPLAIN).
|
|
|
|
Wed Aug 16 17:11:22 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* toplev.c (compile_file), cplus-lex.c (yylex): Use setjmp/longjmp
|
|
to communicate fact that dump was just performed. This prevents
|
|
duplicate bytes being written to the asm file, due to inline
|
|
functions being written out by both original and dumped compilers.
|
|
|
|
* toplev.c (compile_file): Hack to make dumped compiler move bytes
|
|
quickly from old asm file to new.
|
|
|
|
* cplus-search.c (build_mi_virtuals,free_mi_matrix): Pointer
|
|
arithmetic for mi_vmatrix accesses were off by 1.
|
|
|
|
* cplus-class.c (build_method_call): Handle case where INSTANCE
|
|
has a POINTER_TYPE type. This is when it is a dummy argument for
|
|
`operator new ()'.
|
|
|
|
Tue Aug 15 00:05:49 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (grokclassfn): `const' member function information
|
|
was being lost.
|
|
|
|
* cplus-class.c (build_method_call): Generate error message when
|
|
passing const objects to non-const member functions.
|
|
|
|
* cplus-class.c (finish_struct): METHOD_VEC must track the object
|
|
being grown on the class obstack.
|
|
|
|
* cplus-method.c (dump_type{_prefix}): Print `class' instead of
|
|
`struct' if declared as class.
|
|
|
|
* cplus-method.c (build_{decl,typename}_overload,do_actual_overload,
|
|
fndecl_as_string): Distinguish `const' member functions from
|
|
normal member functions.
|
|
|
|
* cplus-search.c (get_base_type): Distinguish whether we want to
|
|
know if a public field of baseclass is protected, or whether a
|
|
conversion from derived to base class is protected by passing
|
|
either 1 or 2 to the argument PROTECT.
|
|
* cplus-search.c (get_base_distance): If protect is non-zero,
|
|
always emit an error message if conversion from derived to base
|
|
class is across a private visibility boundary.
|
|
|
|
* cplus-cvt.c (convert_to_reference): Don't violate visibility
|
|
rules when converting to references. Add parameter PROTECT to
|
|
control this behavior. All callers changed.
|
|
* cplus-cvt.c (build_up_reference): Ditto.
|
|
|
|
Mon Aug 14 00:03:46 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* stmt.c (expand_end_case): Incorporate rfg's bugfix for
|
|
optimizing case statements with signed negative test term.
|
|
|
|
* cplus-search.c (reinit_search_statistics): New function.
|
|
* toplev.c (compile_file): Call that function if BEEN_HERE_BEFORE.
|
|
|
|
* cplus-decl.c: Remove explicit initializations from static
|
|
variables--let them sit in common rather than data space.
|
|
* cplus-method.c: Ditto.
|
|
|
|
* Makefile,toplev.v, cplus-decl.c, cplus-lex.c: Incorporated
|
|
changes from Bryan Boreham <kewill!bryan@uunet.uu.net> to dump a
|
|
running GNU C++ for later reexecing.
|
|
* unexec.c,lastfile.c: borrowed from GNU Emacs
|
|
* unex-addr.c,getpagesize.h: New files
|
|
|
|
* Aug 14 13:07 g++.xtar.Z on ~ftp/pub
|
|
|
|
* cplus-decl.c (finish_file): Handle case where initializer for
|
|
one static aggregate is another. Do so by disabling code which
|
|
assumed the wrong thing in that case.
|
|
|
|
* cplus-search.c, cplus-tree.c, cplus-class.c: Major surgery on
|
|
assoc lists. Virtual baseclasses are no longer represented in the
|
|
main assoc list of a type. CLASSTYPE_VBASECLASSES already holds
|
|
such information. Various functions changed and/or simplified to
|
|
use value from that assoc list when needed.
|
|
|
|
* cplus-decl.c (grokdeclarator): Don't get confused by
|
|
non-storageclass bits in SPECBITS when DECL_CONTEXT == FIELD.
|
|
|
|
* cplus-init.c (expand_aggr_init_1): Only check whether a new
|
|
value has been assigned to `this' by the base class if
|
|
FLAG_THIS_IS_VARIABLE is nonzero.
|
|
|
|
* cplus-init.c (expand_aggr_init_1,build_new): Function
|
|
`expand_aggr_vbase_init_1' was the wrong thing. Change these
|
|
functions to call `expand_aggr_vbase_init' instead.
|
|
Also, #ifdef'd out `expand_aggr_vbase_init_1'.
|
|
|
|
* cplus-search.c: Move assoc code from here...
|
|
* cplus-tree.c: ...to here.
|
|
|
|
* cplus-decl.c (lang_printable_name): Don't print return type for
|
|
constructors or destructors.
|
|
|
|
* cplus-class.c (finish_struct): Set TYPE_NEEDS_CONSTRUCTING bit
|
|
if any default members.
|
|
|
|
* cplus-decl.c (finish_file): Remove test for
|
|
TYPE_NEEDS_CONSTRUCTING when considering vars in
|
|
STATIC_AGGREGATES. If something made it to this list, it should
|
|
be initialized.
|
|
|
|
Sun Aug 13 14:25:55 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c: Rename static variable GLOBAL_AGGREGATES to
|
|
STATIC_AGGREGATES.
|
|
* cplus-decl.c (finish_decl): Put static aggregates on the
|
|
STATIC_AGGREGATES list if the VAR_DECL is TREE_STATIC. It does
|
|
not have to be at the global_binding_level to get this treatment.
|
|
Also, rename variable OLDGLOBAL to OLDSTATIC, and remove error
|
|
messages which are no longer needed due to this change.
|
|
|
|
* cplus-typeck.c (comptypes): Qualifiers must match. (Fix taken
|
|
from GCC).
|
|
|
|
* cplus-init.c (expand_aggr_{vbase}_init,expand_recursive_init):
|
|
provide arguments INPUT_FILENAME and LINENO to
|
|
`expand_asm_operands'.
|
|
* cplus-search.c (init_vbase_pointers,build_vbase_vtables_init):
|
|
Ditto.
|
|
|
|
* cplus-class.c (push_lang_context): Don't set current_lang_name
|
|
if it is not a name we recognize.
|
|
|
|
* All GNU C++ files: Merged changes from 1.35.95 to 1.35.96.
|
|
|
|
Sat Aug 12 00:27:43 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (finish_function): Call use_variable on
|
|
CURRENT_VTABLE_DECL if it is non-NULL.
|
|
|
|
* cplus-decl.c (finish_decl): Call build_indirect_ref instead of
|
|
building the INDIRECT_REF by hand when setting the decl reference
|
|
slot.
|
|
|
|
* cplus-obstack.h: New file. Defines obstack_int_grow and
|
|
obstack_ptr_grow. Cuts many calls to bcopy.
|
|
* cplus-class.c: Use cplus-obstack.h instead of obstack.h.
|
|
* cplus-search.c: Ditto.
|
|
|
|
* cplus-parse.y (aggr): Fix minor nits in error messages.
|
|
|
|
* cplus-class.c (finish_struct): Removed code which redundantly
|
|
called `finish_decl' on static class members.
|
|
|
|
* cplus-decl.c (finish_decl): C++ 2.0 now permits static class
|
|
members to be of types with constructors.
|
|
|
|
* cplus-search.c (bfs_unmark_finished_struct): Don't call
|
|
assoc_value if TYPE == CURRENT_CLASS_TYPE.
|
|
|
|
* cplus-search.c (assoc_value): Call compiler_error if we have
|
|
multiple baseclass hits. Also, make this function look for
|
|
matches recursively. This saves having to flatten out the
|
|
hierarchy all the time, saving storage.
|
|
|
|
* cplus-init.c (expand_recursive_init_1): Take into account fact
|
|
that there is no virtual function table initialization needed if
|
|
CLASSTYPE_NEEDS_VIRTUAL_REINIT set TREE_VALUE (init_list) to
|
|
NULL_TREE.
|
|
* cplus-class.c (build_class_init_list): Set up init lists
|
|
correctly if the derived class just takes virtual function table
|
|
initialization from the base class.
|
|
|
|
* cplus-init.c (finish_base_init): Unmark fields initialized which
|
|
belong to base classes.
|
|
|
|
* cplus-decl.c (grokdeclarator,duplicate_decls): Implement C++ 2.0
|
|
interpretation of `const'.
|
|
|
|
* Aug 12 08:33 g++.xtar.Z on ~ftp/pub
|
|
|
|
* cplus-typeck.c (commontype): Case for REFERENCE_TYPE appeared to
|
|
be missing.
|
|
* cplus-typeck.c (comptypes): Ditto.
|
|
|
|
* cplus-typeck.c (comp_target_parms): Braino caused this function
|
|
to return after processing just the first argument!
|
|
|
|
* cplus-typeck.c (comp_target_parms,compparms): Take
|
|
contravariance into account for argument lists.
|
|
|
|
Fri Aug 11 04:58:40 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-tree.c (list_hash): Implement hashing scheme for
|
|
unchanging list nodes, such as compose TYPE_BASELINKS.
|
|
Several new functions and data structures implement this.
|
|
* cplus-search.c (get_baselinks): Call hash_tree_cons instead of
|
|
tree_cons to get fresh nodes.
|
|
|
|
* tree.c (init_tree): Remove call to bzero for hash_table.
|
|
|
|
* cplus-init.c (expand_aggr_init): Typo in call to
|
|
expand_vec_init.
|
|
|
|
* newld.c (decode_command): Fix failure to bzero all entries in
|
|
FILE_TABLE.
|
|
|
|
* cplus-lex.c (cons_up_dtor_for_type): Add missing QUALS
|
|
parameter in call to start_method.
|
|
|
|
* cplus-decl.c (start_function): Set TREE_READONLY and
|
|
TREE_VOLATILE bits of C_C_D.
|
|
* cplus-class.c (popclass): Ditto.
|
|
|
|
* cplus-tree.c (build_cplus_method_type): New function. Like
|
|
`build_method_type', but permits qualifiers for the instance
|
|
variable.
|
|
* cplus-tree.h: Declare it.
|
|
* cplus-decl.c (grokdeclarator,grokclassfn): Call this function
|
|
instead of build_method_type.
|
|
|
|
* tree.c (build_method_type): Set TYPE_METHOD_BASETYPE from the
|
|
TYPE_MAIN_VARIANT of BASETYPE.
|
|
|
|
* cplus-lex.c (gplus.input): Change `friend' from TYPE_QUAL to
|
|
SCSPEC.
|
|
|
|
* cplus-parse.y (fn.def1): Permit const and volatile member
|
|
functions.
|
|
* cplus-method.c (stash_inline_prefix): Handle case of const and/or
|
|
volatile member functions declared inside class.
|
|
* cplus-decl.c (start_{method,function}): Grok const and volatile
|
|
member functions.
|
|
* cplus-decl.c (grokdeclarator): New parameter QUALS.
|
|
|
|
* cplus-typeck.c (readonly_warning_or_error): If ARG is a
|
|
PARM_DECL, print its name. Also, if the message is due to the
|
|
underlying structure of a COMPONENT_REF, tell user the
|
|
member name instead of trying to hunt down the structure name.
|
|
also, if ARG is a reference variable or parameter, name the
|
|
reference as well.
|
|
|
|
* cplus-cvt.c (build_up_reference): Handle case where we build a
|
|
reference to a sub-object of an object which uses multiple
|
|
inheritance.
|
|
|
|
* cplus-class.c (finish_struct): Simplify conditions under which
|
|
CLASSTYPE_NEEDS_VIRTUAL_REINIT is used, and use it.
|
|
|
|
Thu Aug 10 00:13:03 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-parse.y (member_init): If base class is virtual, save the
|
|
intializer on the permanent_obstack.
|
|
|
|
* cplus-init.c (expand_aggr_vbase_init_1): New function. Called
|
|
to actually walk the virtual baseclass initialization list.
|
|
|
|
* cplus-init.c (expand_aggr_vbase_init): New argument DECL is
|
|
the FUNCTION_DECL for the constructor by which this object is
|
|
initialized. From that constructor comes the virtual base class
|
|
initialization list.
|
|
|
|
* cplus-init.c (finish_base_init): Store initializers for virtual
|
|
base classes.
|
|
|
|
* cplus-tree.h (lang_decl): Add new field `vbase_init_list'.
|
|
Holds initializers for virtual base classes.
|
|
|
|
* cplus-init.c (build_new): Arrange to initialize virtual
|
|
baseclasses before calling constructor if FLAG_THIS_IS_VARIABLE
|
|
is zero. Otherwise, constructor will call it on allocation.
|
|
|
|
* cplus-cvt.c (convert_to_nonzero_pointer): If EXPR is already
|
|
of type TYPE, don't build a NOP_EXPR; instead, just return
|
|
EXPR.
|
|
|
|
* cplus-class.c (build_method_call): If INSTANCE is NULL_TREE,
|
|
then pre-allocate storage for the constructor. After that, if
|
|
there are virtual baseclasses to initialize, initialize them right
|
|
away. Then call constructor with resulting argument.
|
|
|
|
* cplus-decl.c (flag_this_is_variable): Change default from 1 to 0.
|
|
* cplus-decl.c (lang_decode_option): Recognize
|
|
`-fthis-is-variable' on command line.
|
|
* cplus-decl.c (finish_function): Don't emit test for whether `this'
|
|
is zero if FLAG_THIS_IS_VARIABLE is zero. Check both constructor
|
|
and destructor case.
|
|
* cplus-decl.c (grokclassfn): Make `this' a *const if
|
|
!FLAG_THIS_IS_VARIABLE.
|
|
|
|
* cplus-search.c (build_mi_matrix): Initialize MI_SIZE when
|
|
reusing an old mi-matrix.
|
|
|
|
* cplus-cvt.c (convert_to_nonzero_pointer): Abort if argument is
|
|
integer_zerop.
|
|
|
|
* cplus-class.c (build_method_call): Simplify code, mostly for
|
|
speed.
|
|
|
|
* cplus-search.c (lookup_field): Use my_tree_cons instead of
|
|
tree_cons for looking up fields.
|
|
|
|
* cplus-search.c (my_{tree_cons,build_string}): Use SET_TREE_CODE
|
|
to set tree code.
|
|
|
|
* cplus-decl.c (finish_decl): Initialize globals whose type needs
|
|
constructing, but ! IS_AGGR_TYPE (type), with empty_init_node to
|
|
keep assemble_variable from crashing.
|
|
|
|
* cplus-search.c (build_mi_matrix): Take into account
|
|
CLASSTYPE_N_VBASECLASSES when computing MI_SIZE.
|
|
* cplus-class.c (finish_struct): Braino: set
|
|
CLASSTYPE_N_VBASECLASSES after calling layout_vbasetypes.
|
|
|
|
* cplus-class.c (finish_base_struct): Set MAX_HAS_VIRTUAL
|
|
regardless of whether base class is a virtual baseclass or not.
|
|
* cplus-class.c (finish_struct): Also, set MAX_HAS_VIRTUAL
|
|
taking into account virtual baseclasses.
|
|
* cplus-tree.c (layout_vbasetypes): Takes new arg PMAX which
|
|
passes info of maximum number of virtual functions defined in
|
|
virtual baseclasses from this function to finish_struct.
|
|
|
|
* cplus-class.c (finish_struct): Set MAX_HAS_VIRTUAL if
|
|
HAS_VIRTUAL is set.
|
|
|
|
* cplus-class.c (modify_vtable_entry): If VFIELD can be
|
|
NULL_TREE, if the current class has no virtual function except
|
|
those inherited from a virtual baseclass. In such a case,
|
|
NORMAL will be zero.
|
|
|
|
* cplus-lex.c (copy_type_lang_specific): Copy the array of
|
|
basetypes so that CLASSTYPE_BASECLASS (t, i) gives the right
|
|
baseclass.
|
|
|
|
Wed Aug 9 10:41:17 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-typeck.c (c_expand_return): Don't pass return value though
|
|
a temporary if there are no pending cleanups.
|
|
* stmt.c (no_pending_cleanups): New function to support above
|
|
change.
|
|
|
|
* stmt.c (assign_parms): Add test to see if we can avoid calling
|
|
convert_units if possible.
|
|
|
|
* cplus-decl.c (grokparms): Use variables LAST_RESULT and
|
|
LAST_DECL to eliminate need to call `chainon'.
|
|
|
|
* stmt.c (expand_fixup,expand_start_bindings): Use static variable
|
|
EMPTY_CLEANUP_LIST to short-circuit cleanup checking, and also
|
|
cut down on calls to tree_cons, in new binding contours, which are
|
|
quite frequent in C++ (20% of calls to tree_cons, and 5% of total
|
|
TREE_LIST nodes).
|
|
|
|
* stmt.c (expand_start_*): Build new nesting level structure on
|
|
obstack instead of calling malloc. New variable STMT_OBSTACK.
|
|
New function `init_stmt'.
|
|
* toplev.c: Call `init_stmt'.
|
|
|
|
* obstack.h (obstack_{ptr,int}_grow): New macros.
|
|
|
|
* cplus-cvt.c (build_default_{binary,unary}_type_conversion):
|
|
Handle case where one (or both) incoming types are "C" types, not
|
|
"C++" types.
|
|
|
|
* cplus-cvt.c (convert_to_pointer): If we go through any virtual
|
|
base pointers, make sure that casts to BASETYPE from the last
|
|
virtual base class use the right value for BASETYPE.
|
|
|
|
* cplus-search.c (dfs_find_vbases): VBASES are now TREE_VECs,
|
|
not TREE_LISTS. Change variable named OFFSET_INFO to ASSOC,
|
|
and use accordingly.
|
|
|
|
* cplus-search.c (dfs_get_vbase_types): Make assocs in VBASE_TYPES
|
|
contain the true basetype, not its MAIN_VARIANT.
|
|
|
|
Tue Aug 8 00:19:43 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* stor-layout.c (layout_basetypes): Don't inherit assoc info.
|
|
Synthesize it instead.
|
|
|
|
* cplus-class.c (finish_struct): Reenable code which fills in
|
|
virtual function tables of virtual baseclasses.
|
|
|
|
* cplus-class.c (finish_struct): Fill in virtual function table
|
|
with values which come from virtual or non-leftmost baseclasses.
|
|
These are not filled in correctly by `modify_vtable_entry', which
|
|
for these cases, only correctly allocates their skeleton.
|
|
|
|
* cplus-class.c (modify_vtable_entry): Only call get_base_distance
|
|
when BASE != CONTEXT.
|
|
|
|
* cplus-search.c (get_base_distance): Don't push a search_stack
|
|
level until we know we need it and will use it.
|
|
|
|
* cplus-class.c (modify_vtable_entry): Once we know what vtable is
|
|
of interest, set BASE to the best approximation of T's vtable we
|
|
know. I.e., set it to the vtable for the immediate super-class of
|
|
T.
|
|
|
|
Mon Aug 7 17:12:31 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (finish_struct): When extending the bounds of the
|
|
virtaul function table, keep VFIELDS as it was; don't move it up
|
|
the inheritance tree.
|
|
|
|
* cplus-class.c (finish_struct): No need to allocate a lang_decl
|
|
for the virtual function table pointer FIELD_DECL. Others need
|
|
bits, but not bytes that FUNCTION_DECLs need.
|
|
|
|
* cplus-init.c (build_virtual_init): For now, assume that FOR_TYPE
|
|
and TYPE may be distinct, so use assoc lists to find the right
|
|
vtable.
|
|
|
|
* cplus-init.c (expand_recursive_init_1): Initialize the virtual
|
|
function table of sub-components of aggregates driven by
|
|
sub-component. Otherwise, we have to initialize the virtual
|
|
function table driven by the caller who knows what sub-components
|
|
must be initialized. Question: will this cause multiple
|
|
initialization of vtables which are not down the left-hand side?
|
|
Answer is probably yes.
|
|
|
|
* tree.c (make_tree_vec): New function.
|
|
|
|
* tree.c (copy_node): Now handles TREE_VEC correctly.
|
|
|
|
* cplus-search.c ({make,copy}_assoc,assoc_value,debug_dump_assoc):
|
|
Change representation of assoc list from TREE_LIST to TREE_VEC
|
|
representation.
|
|
* cplus-tree.h (ASSOC_* macros): Also here.
|
|
|
|
* cplus-typeck.c (process_init_constructor): Don't complain about
|
|
non-initialization of static class members, regardless of whether
|
|
they are in global scope or not. (Previously only complained when
|
|
at global scope.)
|
|
|
|
* cplus-class.c (finish_struct): Allocate method_vec if members
|
|
need destructors.
|
|
|
|
Sun Aug 6 10:23:31 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (finish_struct): Eliminate redundant
|
|
initialization of class fields to 0.
|
|
|
|
* cplus-parse.y (parm rules): Use void_list_node instead of
|
|
build_tree_list (NULL_TREE, void_type_node) where possible.
|
|
|
|
* print-tree.c (dump): Handle TREE_VEC case.
|
|
|
|
* cplus-init.c (add_method): Modified, and moved to cplus-class.c.
|
|
|
|
* cplus-tree.h (lang_type): Change representation of list of
|
|
member functions from list of lists to vector of lists.
|
|
* cplus-class.c (finish_struct,build_method_call): Also here.
|
|
* cplus-method.c (do_inline_function_hair): Also here.
|
|
* cplus-decl.c (grokclassfn): Also here.
|
|
* cplus-init.c (build_delete,build_member_ref): Also here
|
|
* cplus-ptree.c (walk_lang_type): Also here.
|
|
* cplus-search.c (lookup_fnfields{_1},get_baselinks,dfs_pushdecls,
|
|
dfs_compress_decls,dfs_popdecls): Also here.
|
|
* cplus-typeck.c (build_component_ref): Also here.
|
|
* dbxout.c (dbxout_type): Also here.
|
|
|
|
* cplus-class.c (build_method_call): Remove vestigal use of
|
|
OVERLOAD_MAX_LEN.
|
|
|
|
Sat Aug 5 09:49:48 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (grokparms): Reuse TREE_LIST node in usual case of
|
|
parameter processing.
|
|
|
|
* cplus-decl.c (init_decl_processing): Do things here which used
|
|
to be done in toplev.c
|
|
* toplev.c (various places): Merge with GCC.
|
|
|
|
Fri Aug 4 17:47:24 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* stor-layout.c (genop): Avoid creating new nodes when old ones
|
|
will do.
|
|
* stor-layout.c (build_int): Cache sizes we have made for types.
|
|
|
|
Thu Aug 3 21:44:04 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (pushdecl): Canonicalize enum typedefs same as
|
|
struct, class, and unions.
|
|
|
|
* cplus-init.c (resolve_member_ref): When member is of
|
|
METHOD_TYPE, return logical address of the member, not the member
|
|
itself. The member itself has type METHOD_TYPE, which has mode
|
|
EPmode, which is not a valid mode for expand_expr.
|
|
|
|
* cplus-init.c (expand_vec_delete): When calling vector delete on
|
|
store which does not need destructors, just ignore the argument,
|
|
and delete the container (array) instead.
|
|
|
|
* cplus-decl.c (start_function): Handle case where OLDDECL comes
|
|
back as a TREE_LIST.
|
|
|
|
Wed Aug 2 10:54:54 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* collect.c (process): Initialize ldptr to NULL if COFF is defined.
|
|
|
|
* cplus-method.c (stash_inline_prefix): String name of function is
|
|
IDENTIFIER_POINTER (DECL_NAME (...)), not DECL_NAME.
|
|
|
|
Mon Jul 31 12:14:35 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (finish_decl): Handle case where INIT can be a
|
|
TREE_LIST when initializing a named return value. Specifically,
|
|
translate a TREE_LIST into a COMPOUND_EXPR when initializing a
|
|
referece.
|
|
|
|
* toplev.c (compile_file): Gripe about *non*-extern functions
|
|
declared static but not defined.
|
|
|
|
* cplus-init.c (build_delete): Keep ADDR parameter from being
|
|
evaluated multiple times if TREE_VOLATILE.
|
|
|
|
* cplus-decl.c (grok_function_init): Note whether DECL is an
|
|
uninheritable virtual (i.e., a virtual function of an "abstract
|
|
class").
|
|
* cplus-tree.h (lang_decl): Add bit to record above info.
|
|
* cplus-class.c (build_method_call): Give error if compiler can
|
|
detect that user is attempting to call this function for an object
|
|
whose type is that of the "abstract class".
|
|
|
|
* gcc.c (link_spec): Make libg++.a available via %s rather than
|
|
from -lg++.
|
|
|
|
Fri Jul 28 00:22:14 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-typeck.c (comp_target_types): Take contravariance into
|
|
account for OFFSET_TYPE.
|
|
|
|
* cplus-decl.c (grokdeclarator): When declaring an array, always
|
|
call suspend momentary, since the TYPE_DOMAIN of the array may be
|
|
needed later, for instance by expand_vec_delete.
|
|
* cplus-parse.y (nonmomentary_expr): Second change needed to
|
|
ensure that above condition is met.
|
|
|
|
* cplus-decl.c (grokdeclarator): Handle case of derived class
|
|
declaring member function static when derived class declared
|
|
member function virtual.
|
|
|
|
* cplus-decl.c (grokparms): Permit functions which have default
|
|
arguments to end with `...'.
|
|
cplus-typeck.c (actualparameterlist): Handle this new case.
|
|
|
|
* cplus-typeck.c (c_expand_return): Handle case where conversion
|
|
to return type of function returns ERROR_MARK_NODE.
|
|
|
|
* cplus-init.c (build_delete): Handle case where member type is
|
|
ARRAY_TYPE.
|
|
|
|
* cplus-parse.y (component_decl): Handle case of missing ';'
|
|
before '}'.
|
|
|
|
* cplus-typeck.c (c_expand_start_case): Handle case where switch
|
|
quantity is a MEMBER_REF.
|
|
|
|
* cplus-method.c (build_component_type_expr): Handle case of
|
|
calling non-virtual type conversion operators.
|
|
|
|
* cplus-decl.c (shadow_tag): Make permanent any type created here.
|
|
|
|
* gcc.c (struct compiler compilers[]): add -D__GNUC__ to files
|
|
which are compiled using GNU C++.
|
|
|
|
* cplus-parse.y (primary <- IDENTIFIER): If the identifier is a
|
|
class-local enumeral value, check visibility--it may be a private
|
|
member of a base class.
|
|
|
|
* cplus-cvt.c (convert_force): New function. Permit conversion from
|
|
sub-type to private super-type.
|
|
* cplus-typeck.c (build_c_cast): Call convert_force instead of
|
|
convert.
|
|
|
|
* cplus-typeck.c (build_x_function_call): Don't crash if asked to
|
|
resolve a function which has been declared overloaded, but does
|
|
not yet have any signatures.
|
|
|
|
* cplus-class.c (finish_decl): Don't crash when warning (or
|
|
flagging as error) that array types in static objects cannot need
|
|
constructors.
|
|
|
|
Thu Jul 27 02:26:27 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-tree.c (build_cplus_array_type): Make array type permanent
|
|
if ELT_TYPE is permanent. This is needed because the array type
|
|
may exist within an inline function, and that inline function may
|
|
be expanded at any future time.
|
|
|
|
* cplus-typeck.c (build_scoped_ref): Typo caused fn call to have
|
|
virtually no effect.
|
|
|
|
* cplus-init.c (expand_recursive_init): Make usage of global
|
|
INIT_PTR reentrant.
|
|
|
|
* cplus-search.c (dfs_pushdecls): Don't try initializing a
|
|
TYPE_DECL, just continue through it.
|
|
|
|
* integrate.c (access_parm_map): Don't compensate for
|
|
BYTES_BIG_ENDIAN if parm is BLKmode.
|
|
|
|
* stmt.c (various places): Make stmt.c agree much more closely
|
|
with GCC's stmt.c. Now only a few places where there are
|
|
differences. These have to do with calling do_pending_adjust
|
|
before running cleanups, and using `lang_printable_name' instead
|
|
of DECL_PRINT_NAME to assign to `current_function_name'.
|
|
|
|
Wed Jul 26 15:04:45 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-decl.c (finish_decl): If decl is static, but initialized
|
|
by non-static initializer (such as an object initialized by a
|
|
constructor), use a special initializer to make the decl lay down
|
|
in data rather than bss space.
|
|
* varasm.c (assemble_variable): Remove C++-specific code for above
|
|
case.
|
|
|
|
Tue Jul 25 13:10:19 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (modify_vtable_entry): If the base fndecl is
|
|
not contained in the vtable, don't try to modify the vtable.
|
|
This automatically includes virtual functions from virtual base
|
|
classes.
|
|
* cplus-class.c (modify_vtable_entry): If the virtual function
|
|
does come from a virtual base class, remember to change its
|
|
DECL_VINDEX from a FUNCTION_DECL to an INTEGER_CST before
|
|
continuing with the loop. Use the DECL_VINDEX of the base
|
|
FUNCTION_DECL.
|
|
|
|
* cplus-search.c (debug_dump_assoc): New function.
|
|
|
|
Mon Jul 24 11:22:50 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (finish_struct): Break out code to initialize a
|
|
struct with information deriving from its base classes.
|
|
* cplus-class.c (finish_base_struct): New function where that code
|
|
now lives.
|
|
|
|
* cplus-search.c (dfs_get_vbase_types): Make full association
|
|
list; Don't do so only when TREE_VIRTUAL bit is set.
|
|
|
|
Sun Jul 23 20:31:57 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (modify_vtable_entry): Braino caused base
|
|
association to overwrite derived associate, causing base
|
|
virtual functions to appear in derived virtual function tables
|
|
when they shouldn't have.
|
|
|
|
Sat Jul 22 14:48:51 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-lex.c (yylex): Characters are of type `char'
|
|
* cplus-decl.c (lang_decode_option): No longer a need for
|
|
flag_char_charconst.
|
|
* flags.h: ditto.
|
|
|
|
* All GNU C++ files: Merged changes from 1.35 to 1.35.95.
|
|
|
|
Thu May 25 02:56:16 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-init.c (expand_aggr_init_1): make sure to emit error
|
|
message when following an error path.
|
|
|
|
* stor-layout.c (layout_decl): call this function instead of
|
|
cplus_size_in_bytes. This saves many calls to `convert_units'.
|
|
|
|
* cplus-typeck.c (cplus_size): new function, just returns the size
|
|
of the type we are interested in (no units conversion is done).
|
|
|
|
* cplus-decl.c (init_decl_processing): preallocate
|
|
IDENTIFIER_NODES for `this' and `__delete_me__'; saves calls to
|
|
get_identifier.
|
|
|
|
* cplus-parse.y, cplus-lex.c: tried to speed things up. Removed
|
|
vestigial `@' construct from cplus-parse.y. Also parse '(' ')'
|
|
as a single token.
|
|
|
|
* cplus-init.c (add_friend): make sure to return void_type_node if
|
|
we want our callers not to see anything. Also, undo having set
|
|
TREE_GETS_{NEW,DELETE} if the friend we get is global operator new or
|
|
global operator delete.
|
|
|
|
Tue May 23 01:10:51 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-typeck.c (build_modify_expr): Recursive memberwise
|
|
assignment must work on all type variants, not just the main
|
|
variant. Otherwise, we can't assign a const B& to a B&.
|
|
|
|
* cplus-cvt.c (convert_to_pointer): convert to virtual baseclasses
|
|
through virtual baseclass pointers. Also, give error if
|
|
converting up from a virtual baseclass type.
|
|
|
|
Mon May 22 22:03:24 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (finish_struct): remember to give dynamic classes
|
|
a vfield even if they don't define virtual functions (-fSOS).
|
|
|
|
* cplus-decl.c (init_decl_processing): fixed typo: TYPE_POINTER_TO
|
|
does not build a pointer type, but build_pointer_type does.
|
|
|
|
* cplus-decl.c, cplus-init.c: allow builtin functions to be
|
|
declared friends.
|
|
|
|
* cplus-class.c (ideal_candidate): if the best candidates require
|
|
user-defined type conversions, don't reject as ambiguous the
|
|
case where one candidate comes from one class, and the other
|
|
candidates come from base classes of that class.
|
|
|
|
* stor-layout.c (layout_type): after laying out a type, make sure
|
|
that all type variants get the type's size.
|
|
|
|
Fri May 19 13:20:07 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* cplus-class.c (popclass): don't kill out prev_class_type's decls
|
|
if not at the global binding level.
|
|
|
|
* cplus-decl.c: added new field `class_shadowed', which may some
|
|
day be used to implement nested clases.
|
|
|
|
* newld.c (various places): round up size to double word boundary
|
|
if defined(sparc) || defined(sun).
|
|
|
|
* tree.c (lvalue_p): A CALL_EXPR is an lvalue if the return type
|
|
is an addressable type.
|
|
|
|
* cplus-init.c (make_friend_class): fix typo in error message.
|
|
|
|
* cplus-class.c (finish_struct): Don't give error message if class
|
|
is does not define virtual functions which must be defined if
|
|
that class has some of its own.
|
|
|
|
* cplus-class.c (instantiate_type): handle case where user
|
|
requests member function using object, i.e., `x.f'. If f is
|
|
virtual, return the function found in the virtual function table.
|
|
|
|
* stor-layout.c (layout_basetypes): language dependent code
|
|
removed, put in cplus-class.c
|
|
|
|
* stmt.c (expand_goto_internal, expand_end_bindings,
|
|
fixup_cleanups): if cleanups were called on leaving a binding
|
|
contour, and EXIT_IGNORE_STACK is not defined, call
|
|
do_pending_stack_adjust.
|
|
|
|
* gcc.c: recognize ".cxx" as a C++ file name extension.
|
|
|
|
* cplus-typeck.c (convert_for_initialization,
|
|
convert_for_assignment): convert MEMBER_REFs, if possible, to
|
|
members or component refs as appropriate.
|
|
|
|
* cplus-typeck.c (build_member_ref): recognize member refs which
|
|
are not associated with any object in particular (i.e., could
|
|
be, but need not be `this').
|
|
|
|
* cplus-search.c (get_vbase_types): orders the virtual base
|
|
classes so that initialization and anti-initialization are
|
|
performed in correct order. A virtual baseclass is not
|
|
destroyed until all parts of the object which could be using
|
|
that virtual base class are destroyed.
|
|
|
|
* cplus-parse.y: call build_vbase_delete if appropriate.
|
|
|
|
* cplus-init.c (expand_delete): call build_vbase_delete if
|
|
appropriate. No longer deletes parts of objects via virtual
|
|
base classes.
|
|
|
|
* cplus-init.c: new function build_vbase_delete, performs
|
|
destructors on objects with virtual base classes. new function
|
|
build_x_delete calls free-store deallocator on objects without
|
|
running destructors.
|
|
|
|
* cplus-decl.c (pushdecl, shadow_tag, and xref_tag): implement
|
|
C-like behavior in "C" language scope vis a vis type
|
|
declarations.
|
|
|
|
* cplus-decl.c: define macros PUSH_BINDING_LEVEL and
|
|
POP_BINDING_LEVEL. Use these macros where appropriate. Fixed
|
|
bug in popping binding contours in the presence of syntax
|
|
errors.
|
|
|
|
* README, config.g++, make-links.g++: fixed minor glitches
|
|
|
|
Wed May 17 20:34:29 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* stor-layout.c: move code which deletes an incomplete base type
|
|
to cplus-class.c.
|
|
|
|
* cplus-class.c (finish_struct): call `propagate_basetype_offsets'.
|
|
|
|
* cplus-class.c: new function `propagate_basetype_offsets' gives
|
|
correct offsets to base types which are not immediate base types
|
|
in a multiple inheritance lattice.
|
|
|
|
Tue May 16 09:40:00 1989 Michael Tiemann (tiemann at yahi)
|
|
|
|
* Started using ChangeLog for version 1.35.0
|
|
|
|
|