Subversion Repositories tendra.SVN

/*

 * Copyright (c) 2002-2005 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) 1997

    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/sparc/common/proc.c,v 1.2 1998/03/15 16:00:43 pwe Exp $

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

$Log: proc.c,v $

 * Revision 1.2  1998/03/15  16:00:43  pwe

 * regtrack dwarf dagnostics added

 *

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

 * First version to be checked into rolling release.

 *

 * Revision 1.61  1998/01/09  14:59:42  pwe

 * prep restructure

 *

 * Revision 1.60  1997/11/06  09:29:13  pwe

 * ANDF-DE V1.8

 *

 * Revision 1.59  1997/10/28  10:19:05  pwe

 * extra diags

 *

 * Revision 1.58  1997/10/23  09:33:16  pwe

 * prep extra_diags

 *

 * Revision 1.57  1997/10/10  18:32:56  pwe

 * prep ANDF-DE revision

 *

 * Revision 1.56  1997/08/23  13:54:28  pwe

 * initial ANDF-DE

 *

 * Revision 1.55  1997/05/02  11:09:11  pwe

 * dwarf2 re return address offset

 *

 * Revision 1.54  1997/04/24  15:16:31  pwe

 * optim -O0 in tail_call

 *

 * Revision 1.53  1997/04/17  11:59:54  pwe

 * dwarf2 support

 *

 * Revision 1.52  1997/03/26  13:04:45  pwe

 * general proc compatibility

 *

 * Revision 1.51  1997/03/24  17:09:35  pwe

 * reorganise solaris/sunos split

 *

 * Revision 1.50  1997/02/18  11:48:17  pwe

 * NEWDIAGS for debugging optimised code

 *

 * Revision 1.49  1996/09/18  12:03:59  pwe

 * fixed PIC_code

 *

 * Revision 1.48  1996/09/10  14:36:48  pwe

 * fix diags - nested scope, param struct and leaf return

 *

 * Revision 1.47  1996/09/09  12:32:52  pwe

 * protect result during postlude

 *

 * Revision 1.46  1996/09/06  16:50:27  pwe

 * fix outpar doubles for postlude

 *

 * Revision 1.45  1996/09/04  12:41:37  pwe

 * untidy_call must not remove stacked callees

 *

 * Revision 1.44  1996/08/30  17:00:25  pwe

 * ensure space available for struct return

 *

 * Revision 1.43  1996/08/28  16:57:51  pwe

 * postlude with calls and no callers

 *

 * Revision 1.42  1996/08/28  11:47:54  pwe

 * correct postlude with calls

 *

 * Revision 1.41  1996/08/27  14:09:09  pwe

 * ensure all varargs are stored, and ptr is not64bit

 *

 * Revision 1.40  1996/08/22  16:47:10  pwe

 * correct accessing for double params

 *

 * Revision 1.39  1996/06/24  08:46:09  john

 * Removed aggregate initialisation

 *

 * Revision 1.38  1996/06/19  15:39:22  john

 * Fixed register allocation bug

 *

 * Revision 1.37  1996/05/24  10:46:08  john

 * Fixed discarded return for function returning struct/long double

 *

 * Revision 1.36  1996/03/20  15:39:49  john

 * Fix to  double & long double handling

 *

 * Revision 1.35  1996/03/18  09:02:03  john

 * Change to caller move

 *

 * Revision 1.34  1996/02/20  14:16:29  john

 * Fix for caller param lists containing structures.

 *

 * Revision 1.33  1996/01/17  10:29:59  john

 * Fix to stack space usage on tail call

 *

 * Revision 1.32  1996/01/10  17:23:00  john

 * Fix to check_stack

 *

 * Revision 1.31  1996/01/08  11:15:24  john

 * Fix to discarded function return when using out_pars

 *

 * Revision 1.30  1995/12/15  10:26:23  john

 * Changes stack error handling + fixes to postlude for general procs

 *

 * Revision 1.29  1995/11/27  09:22:54  john

 * Fixed register allocation

 *

 * Revision 1.28  1995/11/24  14:51:43  john

 * Fixed bug in register allocation

 *

 * Revision 1.27  1995/11/24  11:41:38  john

 * Fix for postludes

 *

 * Revision 1.26  1995/11/23  12:47:43  john

 * Fix for general procs

 *

 * Revision 1.25  1995/11/17  13:01:08  john

 * Fix to general proc call

 *

 * Revision 1.24  1995/11/16  17:23:43  john

 * Fix to same_callees

 *

 * Revision 1.23  1995/11/16  14:14:00  john

 * Fixed untidy return

 *

 * Revision 1.22  1995/11/16  14:03:28  john

 * Fixed register problems in general procs

 *

 * Revision 1.21  1995/11/07  09:42:09  john

 * Extensive changes to handling of callee parameters in general procs

 *

 * Revision 1.20  1995/11/01  16:13:59  john

 * Changed general proc definition

 *

 * Revision 1.19  1995/10/31  12:48:10  john

 * Change to dynamic callees

 *

 * Revision 1.18  1995/10/27  14:22:54  john

 * change to previous fix

 *

 * Revision 1.17  1995/10/27  10:51:41  john

 * Fix to general procs

 *

 * Revision 1.16  1995/10/25  17:13:18  john

 * Changed stack overflow test to unsigned

 *

 * Revision 1.15  1995/09/29  09:23:09  john

 * Fixed condition for setting Has_no_vcallers

 *

 * Revision 1.14  1995/09/27  13:35:27  john

 * Fix to tail_call

 *

 * Revision 1.13  1995/09/22  15:58:23  john

 * Fix to apply_general_proc

 *

 * Revision 1.12  1995/09/22  13:07:07  john

 * Fix to general procs

 *

 * Revision 1.11  1995/09/15  16:17:02  john

 * New exception handling

 *

 * Revision 1.10  1995/09/04  10:14:22  john

 * Fix to general procs

 *

 * Revision 1.9  1995/08/04  15:46:34  john

 * Fix to general procs

 *

 * Revision 1.8  1995/07/27  16:31:32  john

 * Fixed prototype

 *

 * Revision 1.7  1995/07/18  08:24:34  john

 * Fix to tail calls

 *

 * Revision 1.6  1995/07/14  16:33:23  john

 * Various changes for new spec

 *

 * Revision 1.5  1995/07/04  07:51:45  john

 * *** empty log message ***

 *

 * Revision 1.4  1995/06/30  08:29:35  john

 * Fixed bug in tail_call

 *

 * Revision 1.3  1995/06/14  15:35:44  john

 * Added support for trap error treatment and stack limits.  Also, some

 * reformatting

 *

 * Revision 1.2  1995/05/26  13:00:28  john

 * Changes for new spec (3.1)

 *

 * Revision 1.1.1.1  1995/03/13  10:18:51  john

 * Entered into CVS

 *

 * Revision 1.5  1995/01/17  15:32:24  john

 * Removed structure parameter check.

 *

 * Revision 1.4  1994/12/01  13:07:34  djch

 * with longjmp one can get procs of shape bottom. consider them as returning

 * void

 *

 * Revision 1.3  1994/07/07  16:11:33  djch

 * Jul94 tape

 *

 * Revision 1.2  1994/05/13  13:06:59  djch

 * Incorporates improvements from expt version

 * removed rscope related fns.

 * added RET_IN_CODE, not set -> return at end of leaf, not in middle...

 *

 * Revision 1.1  94/05/03  14:49:48  djch

 * Initial revision

 *

 * Revision 1.8  94/02/21  16:12:49  16:12:49  ra (Robert Andrews)

 * reg_result now returns int, not bool.

 *

 * Revision 1.7  93/09/27  14:53:49  14:53:49  ra (Robert Andrews)

 * In System V the __GLOBAL_OFFSET_TABLE_ starts with only one _.

 *

 * Revision 1.6  93/08/27  11:35:12  11:35:12  ra (Robert Andrews)

 * A number of lint-like changes.

 *

 * Revision 1.5  93/08/13  14:44:13  14:44:13  ra (Robert Andrews)

 * Reformatted.

 *

 * Revision 1.4  93/07/14  11:21:26  11:21:26  ra (Robert Andrews)

 * Misprint when reformatting : .reserved should be .reserve.

 *

 * Revision 1.3  93/07/05  18:23:46  18:23:46  ra (Robert Andrews)

 * Made distinction between the System V assembler and the System V ABI.

 * Added support for PIC (procedure prologue).

 *

 * Revision 1.2  93/06/29  14:30:40  14:30:40  ra (Robert Andrews)

 * Changed an error message.

 *

 * Revision 1.1  93/06/24  14:59:01  14:59:01  ra (Robert Andrews)

 * Initial revision

 *

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

*/

/*

  This file contains functions which handle the various aspects

  of procedure definition and invocation.

*/

#define SPARCTRANS_CODE

#include "config.h"

#include "common_types.h"

#include "myassert.h"

#include "addrtypes.h"

#include "tags.h"

#include "expmacs.h"

#include "installtypes.h"

#include "exp.h"

#include "exptypes.h"

#include "maxminmacs.h"

#include "shapemacs.h"

#include "basicread.h"

#include "proctypes.h"

#include "eval.h"

#include "move.h"

#include "comment.h"

#include "getregs.h"

#include "guard.h"

#include "locate.h"

#include "codehere.h"

#include "inst_fmt.h"

#include "sparcins.h"

#include "bitsmacs.h"

#include "labels.h"

#include "regexps.h"

#include "regmacs.h"

#include "regable.h"

#include "flags.h"

#include "special.h"

#include "translat.h"

#include "makecode.h"

#include "out.h"

#include "proc.h"

#include "szs_als.h"

#include "externs.h"

#include "sparctrans.h"

#ifdef NEWDIAGS

#include "dg_globs.h"

#endif

#ifdef NEWDWARF

#include "dw2_config.h"

#include "dw2_info.h"

#include "dw2_basic.h"

#include "dw2_extra.h"

#endif

/*

  CODE GENERATION STATE FOR THE CURRENT PROCEDURE

*/

static void alloc_space(int,int);

static void alloc_reg_space(int,int);

extern int call_base_reg;

struct proc_state proc_state;

static exp current_proc;

bool Has_vcallees = 0;

bool Has_no_vcallers = 0;

bool in_general_proc = 0;

#ifdef GENCOMPAT

bool May_have_callees = 0;

#endif

static bool in_postlude = 0;

extern char * proc_name;

int local_reg = R_I5;

int callee_start_reg = R_I5;   /* will point to start of callee params */

int callee_end_reg = R_I4;     /* will point to end of callee params.  Only

				  used for variable or dynamic parameter

				  lists */

int callee_start_reg_out = R_O5;

int callee_end_reg_out = R_O4;

static int vc_call = 0;

int aritherr_lab = 0;

int stackerr_lab = 0;

int local_stackerr_lab = 0;

#define is64(X)((name(X) ==u64hd) || (name(X) ==s64hd))

void call_tdf_main

(void) {

  outs("\tcall\t___TDF_main\n");

  outs("\tnop\n");

  return;

}

/*

  FIND TEMPORARY MEMORY

  This is a temporary location in the stack frame callee parameter

  save area that can be used in short instruction sequences, such

  as moving between float and fixed registers.  It is initialised

  in the procedure prelude.

*/

baseoff mem_temp

(int byte_offset) {

  baseoff b;

  b = proc_state.mem_temp0;

  /* only 2 words of temp allocated */

  assert(byte_offset >= 0 && byte_offset < 8);

  b.offset += byte_offset;

  return(b);

}

/*

  Postlude chaining function

*/

static postlude_chain * old_postludes;

void update_plc

(postlude_chain* chain, int maxargs) {

  while (chain) {

    exp pl = chain->postlude;

    while (name(pl) == ident_tag) {

      if (name(son(pl)) == caller_name_tag)

	no(pl) += (maxargs<<1);

      pl = bro(son(pl));

    }

    chain = chain->outer;

  }

  return;

}

/*

  ENCODE A PROCEDURE DEFINITION

*/

makeans make_proc_tag_code

(exp e, space sp, where dest, int exitlab) {

  procrec *pr = &procrecs[no(e)];

  needs *ndpr = &pr->needsproc;

  spacereq *sppr = &pr->spacereqproc;

  long pprops = (long)(ndpr->prps);

  bool leaf = ( bool ) ( ( pprops & anyproccall ) == 0 ) ;	/* LINT */

  long maxargs = ndpr->maxargs ;/* maxargs of proc body in bits */

  long st = sppr->stack ;		/* space for locals in bits */

  struct proc_state old_proc_state;

  makeans mka;

  exp par;

  old_postludes = (postlude_chain*)NULL;

  current_proc = e;

  Has_vcallees = (name(e) == general_proc_tag) && (proc_has_vcallees(e));

  Has_no_vcallers = (name(e) == proc_tag) || (!proc_has_vcallers(e));

  in_general_proc = (name(e) == general_proc_tag);

#ifdef GENCOMPAT

  May_have_callees = proc_may_have_callees(e);

#endif

  /* save & reinstate proc_state for nested procs */

  old_proc_state = proc_state;

  mka.lab = exitlab;

  mka.regmove = NOREG;

#ifdef GENCOMPAT

  if (May_have_callees) {

#else

  if (in_general_proc) {

#endif

    sp = guardreg(callee_start_reg,sp);

  }

  if (Has_vcallees) {

    sp = guardreg(callee_end_reg,sp);

    outs("\t.optim\t\"-O0\"\n"); /* as -O2 optimises out some moves

				    from %sp to other registers */

  }

  /* this is a procedure definition */

  assert(name(e) == proc_tag || name(e) == general_proc_tag);

  /* set global flag for res_tag */

  proc_state.leaf_proc = leaf;

  /* maxargs is the maxargs in bits of any proc called, not this proc */

  /* SPARC reserved stack area */

  if (leaf) {

    /* reg window dump area */

    assert(maxargs == 0);

    maxargs = (16)* 32;

  }

  else {

    assert(maxargs >= 0);

    /* at least reg param dump for calls */

    if (maxargs < (6)* 32)maxargs = (6)* 32;

    /* plus reg window dump area + hidden struct return param */

    maxargs += (16 + 1)* 32;

  }

  /* use space we are allowing for called procs */

  proc_state.mem_temp0.base = R_SP;

  proc_state.mem_temp0.offset = (16 + 1 + 1)* 4;

  /* double word aligned */

  assert((proc_state.mem_temp0.offset & 7) == 0);

  /* make sure mem_temp () is allowed for */

  if (proc_state.mem_temp0.base == R_SP &&

       maxargs < ((proc_state.mem_temp0.offset + 8) << 3)) {

    /* ie, a leaf proc */

    assert(leaf);

    maxargs = (proc_state.mem_temp0.offset + 8) << 3;

    }

  /* align to 64 bit boundaries */

  maxargs = (maxargs + 63) & ~63;

  st = (st + 63) & ~63;

  /* -----------------------WARNING--------------------------- */

  /* if you alter these then please check boff_env_offset, 'cos

     they're effectively reproduced there..... */

  proc_state.locals_space = st;

  proc_state.locals_offset = 0;

  /*proc_state.params_offset = ( 16 + 1 ) * 32 ;*/

  proc_state.params_offset = PARAMS_OFFSET;

  proc_state.callee_size = ndpr->callee_size;

  /* beyond register window save area and hidden param of

     caller's frame */

  proc_state.frame_size = maxargs + st;

  proc_state.maxargs = maxargs;

  st = proc_state.frame_size >> 3;

#ifdef NEWDWARF

  if (dwarf2) {

    START_BB();

    dw2_start_fde(current_proc);

  }

#endif

  if (name(e) == general_proc_tag) {

    if (proc_has_checkstack(e) && (st > 64)) {

      rir_ins(i_save,R_SP,-64,R_SP);

    }

    else {

      rir_ins(i_save,R_SP,-st,R_SP);

    }

#ifdef NEWDWARF

    if (dwarf2)

      dw2_fde_save();

#endif

#ifdef GENCOMPAT

    if (May_have_callees)

#endif

    {

      int entry_lab = new_label();

      uncond_ins(i_b,entry_lab);

      /*rir_ins(i_save,R_SP,0,R_SP);*/

      if (st>64) {

	rir_ins(i_sub,R_SP, st - 64,R_SP);

      }

      set_label(entry_lab);

    }

  }

  else{

    rir_ins(i_save, R_SP, -st, R_SP);

#ifdef NEWDWARF

    if (dwarf2)

      dw2_fde_save();

#endif

    /* more here about fp */

  }

  /* position independent code */

  if (PIC_code && proc_uses_external(e)) {

    char *g = "__GLOBAL_OFFSET_TABLE_";

    if (sysV_assembler)g++;

    outs("1:\n");

    outs("\tcall\t2f\n");

    outf("\tsethi\t%%hi(%s+ (.-1b)),%%l7\n", g);

    outs("2:\n");

    outf("\tor\t%%l7,%%lo(%s+ (.-1b)),%%l7\n", g);

    outs("\tadd\t%l7,%o7,%l7\n");

#ifdef NEWDWARF

    if (dwarf2)

      lost_count_ins();

#endif

  }

  local_stackerr_lab = 0;

  stackerr_lab = 0;

  if (name(e) == general_proc_tag) {

    if (proc_has_checkstack(e)) {

      baseoff b;

      int rtmp;

      int rt;

      if (st > 64) {

	rt = getreg(sp.fixed);

	rir_ins(i_sub,R_SP,(st - 64),rt);

      }

      else {

	rt = R_SP;

      }

      b = find_tag(TDF_STACKLIM);

      stackerr_lab = new_label();

      rtmp = getreg(guardreg(rt,sp).fixed);

      ld_ins(i_ld,b,rtmp);

      condrr_ins(i_bgtu,rtmp,R_SP,stackerr_lab);

      if (rt != R_SP) {

	rr_ins(i_mov,rt,R_SP);

      }

    }

    /* Here we make a local copy of the callees */

    if (Has_vcallees) {

      baseoff b;

      int copy_lab = new_label();

      int end_copy_lab = new_label();

      /* copy callees to new space (pointed to by reg rdest) */

      int rsize = getreg(sp.fixed);

      int rdest = getreg(guardreg(rsize,sp).fixed);

      int rt = getreg(guardreg(rdest,sp).fixed);

      rrr_ins(i_sub,callee_end_reg,callee_start_reg,rsize);

      condrr_ins(i_be,rsize,R_G0,end_copy_lab);

      alloc_reg_space(rsize,rdest);

      b.offset = 0;

      set_label(copy_lab);

      b.base = callee_start_reg;

      ld_ro_ins(i_ld,b,rt);

      b.base = rdest;

      st_ro_ins(i_st,rt,b);

      rir_ins(i_add,callee_start_reg,PTR_SZ>>3,callee_start_reg);

      rir_ins(i_add,rdest,PTR_SZ>>3,rdest);

      condrr_ins(i_bne,callee_start_reg,callee_end_reg,copy_lab);

      /* now set up the new callee pointers */

      rr_ins(i_mov,rdest,callee_end_reg);

      rrr_ins(i_sub,rdest,rsize,callee_start_reg);

      set_label(end_copy_lab);

    }

#ifdef GENCOMPAT

    else

    if (May_have_callees) {

#else

    else {

#endif

      baseoff b;

      int size = proc_state.callee_size/8;

      int rdest = getreg(sp.fixed);

      int el;

      int rt = getreg(guardreg(rdest,sp).fixed);

      alloc_space(size,rdest);

      b.offset = 0;

      for (el = proc_state.callee_size/8;el>0;el -= (PTR_SZ>>3)) {

	b.base = callee_start_reg;

	b.offset = el - (PTR_SZ>>3);

	ld_ro_ins(i_ld,b,rt);

	b.base = rdest;

	st_ro_ins(i_st,rt,b);

      }

      /* now deallocate old storage.  This is needs for outpars to be

	 accessed properly from postludes. */

#if 0

      rir_ins(i_add,callee_start_reg,((proc_state.callee_size>>3) +7) &~7,callee_start_reg);

      rir_ins(i_sub,callee_start_reg,96,R_FP);

#endif

      rr_ins(i_mov,rdest,callee_start_reg);

    }

  }

  if (do_profile) {

      /* implement -p option, call mcount */

    static int p_lab = 0;

    p_lab++;

    if (sysV_assembler) {

      outs("\t.reserve\tLP.");

      outn(p_lab);

      outs(",4,\".bss\",4\n");

      }

    else {

      outs("\t.reserve\tLP.");

      outn(p_lab);

      outs(",4,\"bss\",4\n");

    }

    insection(text_section);

    outs("\tset\tLP.");

    outn(p_lab);

    outs(",%o0\n");

#ifdef NEWDWARF

    if (dwarf2)

      lost_count_ins();

#endif

    extj_special_ins(i_call, "mcount", 1);

  }

    /* Move params if necessary */

  par = son(e);

  while (name(par) == ident_tag) {

    if (isparam(par)) {

      /* Got a parameter ident */

      int r = (int)props(son(par));

      /* ( r == 0 ) ? ( on stack ) : ( input reg no ) */

/*	assert ( name ( son ( par ) ) == clear_tag ) ;*/

      if (r != 0) {

	/* Parameter in register */

	assert(R_I0 <= r && r <= R_I5);

	if (no(par)!= 0) {

	  if (no(par) == R_NO_REG) {

	    /* struct/union parameter, on stack aleady,

	       nothing useful in reg */

	    assert(!fixregable(par) &&

		     !floatregable(par));

	  }

	  else if (no(par) == r) {

	    if (name(sh(son(par))) == ucharhd) {

	      rir_ins(i_and, r, 255, no(par));

	    }

	    else if (name(sh(son(par))) == uwordhd) {

	      rir_ins(i_and, r, 65535, no(par));

	    }

	  }

	  else {

	    if (name(sh(son(par))) == ucharhd) {

	      rir_ins(i_and, r, 255, no(par));

	    }

	    else if (name(sh(son(par))) == uwordhd) {

	      rir_ins(i_and, r, 65535, no(par));

	    }

	    else {

	      rr_ins(i_mov, r, no(par));

	    }

	  }

	}

	else {

	  /* Parameter in reg move to stack */

	  baseoff stackpos;

	  long size = shape_size(sh(son(par)));

	  int offs = (int)((no(son(par)) +

				 proc_state.params_offset) >> 3);

	  stackpos.base = R_FP;

	  stackpos.offset =offs;

	  switch (size) {

	    case 8: {

	      st_ro_ins(i_stb, r, stackpos);

	      break;

	    }

	    case 16: {

	      st_ro_ins(i_sth, r, stackpos);

	      break;

	    }

	    case 32: {

	      st_ro_ins(i_st, r, stackpos);

	      break;

	    }

	    case 64: {

	      /* A double can be passed first word in reg

		 (R_I5) and second word on stack. Must only

		 store out first word in this case  */

	      st_ro_ins(i_st, r, stackpos);

	      if (r != R_I5) {

		/* float point double passed in fixed

		   point reg pair */

		stackpos.offset += 4;

		st_ro_ins(i_st, r + 1, stackpos);

	      }

	      break;

	    }

	    default : {

	      fail("bad size in make_proc_tag_code");

	      break;

	    }

	  }

	}

      }

      else {

	/* Param on stack, no change */

      }

    }

    par = bro(son(par));

  }

  clear_all();

    if ((pprops & long_result_bit)!= 0) {

      /* structure or union result, address of space to [ %fp+64 ] */

      instore is;

      /* [%fp+64] as per call convention */

      is.adval = 0;

      is.b.base = R_FP;