Subversion Repositories tendra.SVN

/*

 * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of The TenDRA Project nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific, prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS

 * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * $Id$

 */

/*

    		 Crown Copyright (c) 1996

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

/*

			    VERSION INFORMATION

			    ===================

--------------------------------------------------------------------------

$Header: /u/g/release/CVSROOT/Source/src/installers/680x0/common/tests.c,v 1.1.1.1 1998/01/17 15:55:50 release Exp $

--------------------------------------------------------------------------

$Log: tests.c,v $

 * Revision 1.1.1.1  1998/01/17  15:55:50  release

 * First version to be checked into rolling release.

 *

Revision 1.2  1997/11/09 14:15:09  ma

Removed issigned. Use is_signed instead.

Revision 1.1.1.1  1997/10/13 12:42:59  ma

First version.

Revision 1.5  1997/10/13 08:50:11  ma

Made all pl_tests for general proc & exception handling pass.

Revision 1.4  1997/09/25 06:45:35  ma

All general_proc tests passed

Revision 1.3  1997/04/20 11:30:39  ma

Introduced gcproc.c & general_proc.[ch].

Added cases for apply_general_proc next to apply_proc in all files.

Revision 1.2  1997/03/20 12:46:24  ma

Now tag ids are kept in unsigned chars (MAX tag id > 127).

Revision 1.1.1.1  1997/03/14 07:50:18  ma

Imported from DRA

 * Revision 1.1.1.1  1996/09/20  10:56:59  john

 *

 * Revision 1.2  1996/07/05  14:26:52  john

 * Changes for spec 3.1

 *

 * Revision 1.1.1.1  1996/03/26  15:45:17  john

 *

 * Revision 1.3  94/02/21  16:04:20  16:04:20  ra (Robert Andrews)

 * A number of values which were previously bool are now int.

 *

 * Revision 1.2  93/05/24  16:00:03  16:00:03  ra (Robert Andrews)

 * The optimisation which check_anyway is designed to test for has

 * returned.  Some tuning is required.

 *

 * Revision 1.1  93/02/22  17:16:44  17:16:44  ra (Robert Andrews)

 * Initial revision

 *

--------------------------------------------------------------------------

*/

#include "config.h"

#include "common_types.h"

#include "assembler.h"

#include "exp.h"

#include "expmacs.h"

#include "shapemacs.h"

#include "tags.h"

#include "tests.h"

#include "is_worth.h"

#ifndef tdf3

#include "68k_globals.h"

#endif

/*

    CC CONVENTIONS

    HP cc has different conventions to gcc on certain points, most

    noticably on the alignment of bitfields.  Both conventions are

    supported, but the cc conventions are default on the HP.  NeXT

    cc is gcc.

*/

#ifdef hp_cc_conventions

int cc_conventions = 1;

#else

int cc_conventions = 0;

#endif

bool

reused_parameter(exp e)

{

	bool reused = 0;

	exp def, ident_exp;

	def = son(e);

	if (name(def) == name_tag) {

		ident_exp = son(def);

		if (! isvar(ident_exp)) {

			/* This an obtain_tag of a parameter */

			if (name(son(ident_exp)) == formal_callee_tag) {

				reused = cur_proc_use_same_callees;

			}

			else {

				/* caller parameter */

				reused = cur_proc_has_tail_call;

			}

		}

	}

	return reused;

}

/*

    CAN THE VALUE OF AN EXPRESSION BE PUT INTO A REGISTER?

    This routine returns 1 if the expression e can be put into a register.

    It has to have its visible flag false, and to be of a suitable shape.

*/

bool

regable(exp e)

{

	shape sha;

	char n;

	long sz;

	if (isvis(e)) {

		return (0);

	}

	sha = sh(son(e));

	n = name(sha);

	if (n == realhd || n == doublehd) {

		return (1);

	}

	sz = shape_size(sha);

	return (n != cpdhd && n != nofhd && sz <= 32);

}

/*

    DOES AN EXP HAVE NO SIDE EFFECTS?

    This routine returns 1 if e has no side effects.

*/

bool

no_side(exp e)

{

	int n = name(e);

	if (n == ident_tag) {

		return (no_side(son(e)) && (no_side(bro(son(e)))));

	}

	return (is_a(n) || n == test_tag || n == ass_tag || n == testbit_tag);

}

    char n;

/*

    IS AN EXP A PUSHABLE PROCEDURE ARGUMENT?

    Can the expression e be pushed directly onto the stack when it is

    the parameter of a procedure?

*/

bool

push_arg(exp e)

{

	unsigned char n = name(e);

	if (is_a(n)) {

		return (1);

	}

	if (n == apply_tag || n == apply_general_tag) {

		return (reg_result(sh(e)));

	}

	if (n == ident_tag) {

		return (push_arg(son(e)) && push_arg(bro(son(e))));

	}

	return (0);

}

#if 0

/*

    IS A UNION ACTUALLY POINTER VOID?

    No longer used.

*/

#ifndef PTR_VOID_MIN

#define PTR_VOID_MIN	10

#endif

bool

is_ptr_void(shape sha)

{

	bool go;

	int ptrs = 0;

	exp t = son(sha);

	if (t == nilexp) {

		return (0);

	}

	do {

		go = (last(t) ? 0 : 1);

		if (name(sh(t)) != ptrhd) {

			return (0);

		}

		ptrs++;

		t = bro(t);

	} while (go);

	if (ptrs < PTR_VOID_MIN) {

		return (0);

	}

#ifdef PTR_VOID_MAX

	if (ptrs > PTR_VOID_MAX) {

		return (0);

	}

#endif

	return (1);

}

#endif

/*

    IS A SHAPE COMPOUND?

    This routine is designed to test whether a given shape is compound,

    and thus likely to cause problems when it is the parameter of a

    procedure.

*/

bool

cpd_param(shape sha)

{

	char n = name(sha);

	if (!cc_conventions || n == bitfhd) {

		long sz = shape_size(sha);

		if (sz <= 32) {

			return (0);

		}

	}

	return (n == cpdhd || n == nofhd || n == bitfhd || n == s64hd ||

		n == u64hd);

}

/*

    DOES A PROCEDURE RETURN A RESULT OF A GIVEN SHAPE IN A REGISTER?

    cc has two ways of getting results from procedures.  Firstly in the

    register D0 (or D0 and D1 in certain cases) and secondly in a section

    of memory the address of which is passed in at the start of the

    procedure in the A1 register and returned at the end in the D0

    register.  This routine works out whether or not a procedure

    delivering a result of shape sha will use the first method.

*/

int

reg_result(shape sha)

{

	char n = name(sha);

	if (cc_conventions) {

		/* HP cc doesn't return any tuples, unions etc in a register */

		return (n != cpdhd && n != nofhd);

	} else {

		/* Return anything of size <= 32 or 64 in a register */

		long sz = shape_size(sha);

		return (sz <= 32 || sz == 64);

	}

}

/*

    IS A SHAPE OF VARIABLE SIZE?

    This routine returns 1 if sha involves an array.

*/

bool

varsize(shape sha)

{

	return (name(sha) == nofhd ? 1 : 0);

}

#if 0

Use is_signed macro instead

/*

    IS A SHAPE SIGNED?

    This routine returns 1 if the integer variety shape sha is signed

    and 0 otherwise.

*/

bool

issigned(shape sha)

{

	char n = name(sha);

	if (n == ucharhd || n == uwordhd || n == ulonghd) {

		return (0);

	}

	return (1);

}

#endif

/*

    CHECK ON DECLARATION FOR PARAMETER SUBSTITUTION

    This routine checks if the declaration e should be substituted

    for all its uses or not.

*/

int do_sub_params = 1;

int

check_anyway(exp e)

{

#ifndef tdf3

	return 0;

#else

	if (do_sub_params) {

		setmarked(e);

		if (no(e) > 2) {

			return (1);

		}

	}

	return (0);

#endif

}

/*

    IS IT WORTH EXTRACTING A CONSTANT?

*/

int

is_worth(exp c)

{

	unsigned char cnam = name(c);

	return ((!is_o(cnam) && cnam != clear_tag) ||

		/* ignore simple things unless ... */

		(cnam == cont_tag && name(son(c)) == cont_tag &&

		 name(son(son(c))) == name_tag) ||

		(cnam == name_tag && isparam(son(c)) && !isvar(son(c)) &&

		 shape_size(sh(c)) <= 32 && name(sh(c)) != shrealhd));

}