WebSVN – tendra.SVN – Diff – /trunk/src/installers/80x86/common/cproc.c

+/*
+ * 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
  * Revision 1.24  1997/03/20  16:23:35  pwe
  * dwarf2
+ *
  * Revision 1.23  1996/12/13  14:39:19  pwe
  * prep NEWDIAGS
  *
  * Revision 1.22  1996/11/08  16:19:02  pwe
  * check_stack to check before modifying stack
  *
  * Revision 1.21  1996/10/31  12:02:33  pwe
  * correct env_offset used in constant evaluation
  *
  * Revision 1.20  1996/10/29  13:50:51  pwe
  * correct space for patched instructions
+ *
  * Revision 1.19  1996/10/08  07:58:56  pwe
  * revised correction to env_offset v id out_of_line
  *
  * Revision 1.18  1996/10/07  13:31:06  pwe
  * push make_value, and env_offset v id out_of_line
  *
  * Revision 1.17  1996/07/31  12:56:53  pwe
  * restore alloca stack after longjump
  *
  * Revision 1.16  1996/07/09  09:43:35  pwe
  * caller env_offset if callees present, and tidy
+ *
  * Revision 1.15  1996/02/08  13:45:12  pwe
  * Linux elf v aout option
  *
  * Revision 1.14  1996/01/10  09:19:03  pwe
  * profile const & envoffset correction
+ *
  * Revision 1.13  1996/01/05  16:25:22  pwe
  * env_size and env_offset within constant expressions
 #define GLOBALTABLEMASK 0x8
 /* PROCEDURES */
 static void add_odd_bits
-    PROTO_N ( (r) )
-    PROTO_T ( outofline * r )
+(outofline * r)
+{
   if (r != (outofline*)0) {
     if (r -> next == (outofline*)0)
       last_odd_bit = 1;
     add_odd_bits(r -> next);
   simple_set_label(r->labno);
   clear_reg_record(crt_reg_record);
 #ifdef NEWDWARF
   if (dwarf2) {
 #if 1
-    dw2_start_extra_bit (r->body);
+    dw2_start_extra_bit(r->body);
 #else
-    dw2_start_extra_bit (r->dw2_slave);
+    dw2_start_extra_bit(r->dw2_slave);
 #endif
-    START_BB ();
+    START_BB();
+  }
 #endif
   regsinuse = r->regsinuse;
   fstack_pos = r->fstack_pos;
   cond2a = r->cond2a;
   cond2b = r->cond2b;
   repeat_level = r->repeat_level;
   scale = r->scale;
   coder(r->dest, r->stack, r->body);
-  if (name(sh(r->body)) != bothd)  {
+  if (name(sh(r->body))!= bothd) {
     clean_stack();
     jump(r->jr, 0);
+  }
   else
     stack_dec = 0;
 #ifdef NEWDWARF
   if (dwarf2)
 #if 1
-    dw2_end_extra_bit (r->body);
+    dw2_end_extra_bit(r->body);
 #else
-    dw2_end_extra_bit (r->dw2_hi);
+    dw2_end_extra_bit(r->dw2_hi);
 #endif
 #endif
   return;
+}
 static void out_pops
-    PROTO_N ( (tot_sp, push_space, extra, dpos) )
-    PROTO_T ( int tot_sp X int push_space X int extra X int dpos )
+(int tot_sp, int push_space, int extra, int dpos)
+{
 #ifdef NEWDWARF
   int st;
   long dwl0 = 0, dwl1 = 0, dwl2 = 0, dwl3 = 0, dwl4 = 0;
 #endif
   tot_sp -= extra;
   if (no_frame && !stack_aligned_8byte) {
     if (tot_sp != push_space) {
-      outs (" addl $");
+      outs(" addl $");
-      outn ((long)(tot_sp - push_space));
+      outn((long)(tot_sp - push_space));
-      outs (",%esp");
+      outs(",%esp");
       outnl();
 #ifdef NEWDWARF
       if (diagnose && dwarf2)
-	dwl0 = set_dw_text_label ();
+	dwl0 = set_dw_text_label();
 #endif
     };
+  }
   else {
     if (tot_sp != push_space || has_alloca || stack_aligned_8byte) {
-      outs (" leal -");
+      outs(" leal -");
-      outn ((long)push_space);
+      outn((long)push_space);
-      outs ("(%ebp),%esp");
+      outs("(%ebp),%esp");
       outnl();
     };
   };
   /* pop the registers at the end */
   if (no_frame && (min_rfree & 0x40)) {
-    outs (" pop %ebp");
+    outs(" pop %ebp");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl1 = set_dw_text_label ();
+      dwl1 = set_dw_text_label();
 #endif
   };
   if (min_rfree & 0x20) {
-    outs (" pop %esi");
+    outs(" pop %esi");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl2 = set_dw_text_label ();
+      dwl2 = set_dw_text_label();
 #endif
   };
   if (min_rfree & 0x10) {
-    outs (" pop %edi");
+    outs(" pop %edi");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl3 = set_dw_text_label ();
+      dwl3 = set_dw_text_label();
 #endif
   };
   if (min_rfree & 0x8) {
-    outs (" pop %ebx");
+    outs(" pop %ebx");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl4 = set_dw_text_label ();
+      dwl4 = set_dw_text_label();
 #endif
   };
-  if (!no_frame)  {
+  if (!no_frame) {
-    outs (" pop %ebp");
+    outs(" pop %ebp");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl1 = set_dw_text_label ();
+      dwl1 = set_dw_text_label();
 #endif
   };
   outnl();
 #ifdef NEWDWARF
   if (diagnose && dwarf2) {
-    st = fseek (fpout, dpos, 0);
+    st = fseek(fpout, dpos, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
-    dw2_fde_restore_args (dwl0, dwl1, dwl2, dwl3, dwl4, push_space);
+    dw2_fde_restore_args(dwl0, dwl1, dwl2, dwl3, dwl4, push_space);
+  }
 #endif
   return;
+}
 static void out_untidy_pops
-    PROTO_N ( (tot_sp, push_space) )
-    PROTO_T ( int tot_sp X int push_space )
+(int tot_sp, int push_space)
+{
   if (no_frame) {
     int s_offset = tot_sp - push_space;
     if (min_rfree & 0x40) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)s_offset);
+      outn((long)s_offset);
-      outs ("(%esp),%ebp");
+      outs("(%esp),%ebp");
       outnl();
       s_offset += 4;
     };
     if (min_rfree & 0x20) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)s_offset);
+      outn((long)s_offset);
-      outs ("(%esp),%esi");
+      outs("(%esp),%esi");
       outnl();
       s_offset += 4;
     };
     if (min_rfree & 0x10) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)s_offset);
+      outn((long)s_offset);
-      outs ("(%esp),%edi");
+      outs("(%esp),%edi");
       outnl();
       s_offset += 4;
     };
     if (min_rfree & 0x8) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)s_offset);
+      outn((long)s_offset);
-      outs ("(%esp),%ebx");
+      outs("(%esp),%ebx");
       outnl();
       /* s_offset += 4; */
     };
+  }
   else {
     int fm_offset = - push_space;
     if (min_rfree & 0x20) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)fm_offset);
+      outn((long)fm_offset);
-      outs ("(%ebp),%esi");
+      outs("(%ebp),%esi");
       outnl();
       fm_offset += 4;
     };
     if (min_rfree & 0x10) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)fm_offset);
+      outn((long)fm_offset);
-      outs ("(%ebp),%edi");
+      outs("(%ebp),%edi");
       outnl();
       fm_offset += 4;
     };
     if (min_rfree & 0x8) {
-      outs (" movl ");
+      outs(" movl ");
-      outn ((long)fm_offset);
+      outn((long)fm_offset);
-      outs ("(%ebp),%ebx");
+      outs("(%ebp),%ebx");
       outnl();
       /* fm_offset += 4; */
     };
-    outs (" movl 0(%ebp),%ebp");
+    outs(" movl 0(%ebp),%ebp");
     outnl();
   };
   return;
+}
 int cproc
-    PROTO_N ( (p, pname, cname, global, diag_props) )
-    PROTO_T ( exp p X char *pname X int cname X int global X diag_global * diag_props )
+(exp p, char *pname, int cname, int global, diag_global * diag_props)
+{
   exp jr, t, body;
   ash stack;
   int  ms;
   int tot_sp;
   scale = (float)1.0;
   not_in_params = 1;
   not_in_postlude = 1;
   keep_short = 0;
   repeat_level = 0;
-  callee_size = (proc_has_vcallees(p) ? -1 : 0);
+  callee_size = (proc_has_vcallees(p)? -1 : 0);
   ferrsize = 0;
   fpucon = normal_fpucon;
   has_dy_callees = 0;		/* set by scan2 when stack_dec indeterminable */
   has_tail_call = 0;		/* set by scan2, used in coder */
   comp_weights(p);
 /* 8byte align */
   request_align_8byte = permit_8byte_align && useful_double;
-  if (pname[0] != local_prefix[0])
+  if (pname[0]!= local_prefix[0])
     proc_type(pname);
   has_alloca = proc_has_alloca(p);
   must_use_bp = (has_alloca || proc_has_lv(p));
   regsinuse = 0;
   no_frame = 1;
   if (always_use_frame || do_profile || must_use_bp || has_dy_callees ||
         proc_uses_crt_env(p) || proc_has_setjmp(p) || proc_has_asm
-     )
+    )
      no_frame = 0;
   if (request_align_8byte && no_frame) {
     no_frame = 0;
     stack_aligned_8byte = 1;
   min_rfree = 0;		/* total registers used */
   stack_dec = 0;		/* current stack decrement */
   cond1_set = 0;
   cond2_set = 0;		/* state of condition flags is not known
 				*/
-  clear_reg_record (crt_reg_record);
+  clear_reg_record(crt_reg_record);
   stack.ashsize = 0;
   stack.ashalign = 0;
   vc_pointer = nilexp;
 				/* set up params before any diagnostics */
   t = son(p);
   param_pos = 0;
-  while (name(t) == ident_tag && isparam(t) && name(son(t)) != formal_callee_tag)
+  while (name(t) == ident_tag && isparam(t) && name(son(t))!= formal_callee_tag)
+   {
      t = bro(son(t));
    };
   if (name(t) == ident_tag && name(son(t)) == formal_callee_tag)
+   {
      if (callee_size < 0)
 	vc_pointer = t;
      while (name(t) == ident_tag && name(son(t)) == formal_callee_tag)
 	no(t) = param_pos;
 	if (isenvoff(t))
 	  set_env_off(param_pos+64, t);
 	param_pos = rounder(param_pos + shape_size(sh(son(t))), param_align);
 	t = bro(son(t));
       };
      if (callee_size == 0)
 	callee_size = param_pos;
    };
+   {
      exp pp = son(p);
-     while (name(pp) == ident_tag && isparam(pp) && name(son(pp)) != formal_callee_tag)
+     while (name(pp) == ident_tag && isparam(pp) && name(son(pp))!= formal_callee_tag)
+      {
 	ptno(pp) = par_pl;
 	no(pp) = param_pos;
 	if (isenvoff(pp))
 	  set_env_off(param_pos+64, pp);
   if (global) {
-    outs (".globl ");
+    outs(".globl ");
-    outs (pname);
+    outs(pname);
-    outnl ();
+    outnl();
   };
   if (is80486)
     dot_align(16);
   else
     dot_align(4);
   if (diagnose)
 #ifdef NEWDWARF
-    DIAG_PROC_BEGIN (diag_props, global, cname, pname, p);
+    DIAG_PROC_BEGIN(diag_props, global, cname, pname, p);
 #else
-    diag_proc_begin (diag_props, global, cname, pname);
+    diag_proc_begin(diag_props, global, cname, pname);
 #endif
   if (cname == -1)
-    outs (pname);
+    outs(pname);
   else
+    {
       outs(local_prefix);
       outn((long)cname);
     };
-  outs (":");
+  outs(":");
-  outnl ();
+  outnl();
 #ifdef NEWDWARF
   if (diagnose && dwarf2) {
-    START_BB ();
+    START_BB();
-    dwl0 = set_dw_text_label ();
+    dwl0 = set_dw_text_label();
+  }
 #endif
 /* space for setting local displacement label */
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos1 = ftell (fpout);
+  old_pos1 = ftell(fpout);
-  outs ("                          ");
+  outs("                          ");
      /* ".set .LdispNNNN, SSSSS\n" */
-  outnl ();
+  outnl();
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos1a = ftell (fpout);
+  old_pos1a = ftell(fpout);
-  outs ("                             ");
+  outs("                             ");
      /* ".set .LfcwdispNNNN, SSSSS\n" */
-  outnl ();
+  outnl();
   if (!no_frame) {
-    outs (" pushl %ebp");
+    outs(" pushl %ebp");
-    outnl ();
+    outnl();
-    outs (" movl %esp,%ebp");
+    outs(" movl %esp,%ebp");
-    outnl ();
+    outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl1 = set_dw_text_label ();
+      dwl1 = set_dw_text_label();
 #endif
   };
 /* space for pushing fixed point registers */
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos2 = ftell (fpout);
+  old_pos2 = ftell(fpout);
-  outs ("               ");
+  outs("               ");
      /* " pushl %ebx\n" */
 #ifdef NEWDWARF
   if (diagnose && dwarf2)
-    outs (dw_labroom);
+    outs(dw_labroom);
 #endif
-  outnl ();
+  outnl();
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos3 = ftell (fpout);
+  old_pos3 = ftell(fpout);
-  outs ("               ");
+  outs("               ");
      /* " pushl %edi\n" */
 #ifdef NEWDWARF
   if (diagnose && dwarf2)
-    outs (dw_labroom);
+    outs(dw_labroom);
 #endif
-  outnl ();
+  outnl();
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos4 = ftell (fpout);
+  old_pos4 = ftell(fpout);
-  outs ("               ");
+  outs("               ");
      /* " pushl %esi\n" */
 #ifdef NEWDWARF
   if (diagnose && dwarf2)
-    outs (dw_labroom);
+    outs(dw_labroom);
 #endif
-  outnl ();
+  outnl();
   if (no_frame) {
     if (flush_before_tell)
       IGNORE fflush(fpout);
-    old_pos5 = ftell (fpout);
+    old_pos5 = ftell(fpout);
-    outs ("               ");
+    outs("               ");
        /* " pushl %ebp\n" */
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      outs (dw_labroom);
+      outs(dw_labroom);
 #endif
-    outnl ();
+    outnl();
   }
 /* space for subtract from stack pointer */
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos8 = ftell (fpout);
+  old_pos8 = ftell(fpout);
-  outs ("                     ");
+  outs("                     ");
      /* " subl $SSSSS,%esp\n" */
      /* " movl $SSSSS,%eax\n" */
-  outnl ();
+  outnl();
   if (proc_has_checkstack(p)) {
-    checkalloc_stack (reg0, 1);
+    checkalloc_stack(reg0, 1);
   };
 #ifdef NEWDWARF
   if (diagnose && dwarf2) {
-    dwl8 = set_dw_text_label ();
+    dwl8 = set_dw_text_label();
-    dw_entry_pos = dw2_start_fde (dwl0, dwl1);
+    dw_entry_pos = dw2_start_fde(dwl0, dwl1);
   }
 #endif
   if (stack_aligned_8byte) {
     outs(" andl $-8,%esp");
     outnl();
   };
   if (flush_before_tell)
     IGNORE fflush(fpout);
-  old_pos9 = ftell (fpout);
+  old_pos9 = ftell(fpout);
-  outs ("                                    ");
+  outs("                                    ");
      /* "movw $DDDD,0-.LfcwdispNNNN(%ebp)\n" */
-  outnl ();
+  outnl();
-#if islinux || isfreebsd
+#if isdragonfly || isfreebsd || islinux
   if (
+#if isdragonfly
+  !dragonfly_elf &&
+#elif isfreebsd
+  !freebsd_elf &&
-#if islinux
+#elif islinux
 	!linux_elf &&
 #endif
-	pname[0] != local_prefix[0] &&
+	pname[0]!= local_prefix[0] &&
-	!strcmp (pname+prefix_length, "main")) {
+	!strcmp(pname+prefix_length, "main")) {
     out_main_prelude();
+  }
 #endif
   if (do_profile) {
     int  labl = next_lab ();	/* output profile procedure header */
-    outs (".data");
+    outs(".data");
-    outnl ();
+    outnl();
     dot_align(4);
     outs(local_prefix);
-    outs ("P");
+    outs("P");
-    outn ((long)labl);
+    outn((long)labl);
-    outs (":");
+    outs(":");
-    outnl ();
+    outnl();
-    outs (" .long 0");
+    outs(" .long 0");
-    outnl ();
+    outnl();
-    outs (".text");
+    outs(".text");
-    outnl ();
+    outnl();
-    outs (" leal ");
+    outs(" leal ");
     outs(local_prefix);
-    outs ("P");
+    outs("P");
-    outn ((long)labl);
+    outn((long)labl);
-    outs (",%edx");
+    outs(",%edx");
-    outnl ();
+    outnl();
-    outs (" call _mcount");
+    outs(" call _mcount");
-    outnl ();
+    outnl();
   };
   if (PIC_code && proc_uses_external(p))
+   {
   if (proc_uses_crt_env(p) && proc_has_lv(p) && has_alloca)
+   {
      need_preserve_stack = 1;
      stack.ashsize += 32;
      max_stack = stack.ashsize;
-     save_stack ();
+     save_stack();
    };
   scale = (float)1.0;
   last_odd_bit = 0;
   doing_odd_bits = 0;
     add_odd_bits(ol);
+  }
   if (crt_ret_lab_used) {
-    jr = getexp (f_bottom, nilexp, 0, nilexp, nilexp, 0,
+    jr = getexp(f_bottom, nilexp, 0, nilexp, nilexp, 0,
 , 0);
     sonno(jr) = stack_dec;
     ptno(jr) = crt_ret_lab;
     fstack_pos_of(jr) = (prop)first_fl_reg;
-    set_label (jr);
+    set_label(jr);
   };
 	/* If the procedure loads the current env and uses make_lv
 	   it may be the destination of a long_jump. In that case
 	   ebx, esi and edi must be saved at and restored at exit.
 	*/
   if (proc_uses_crt_env(p) && proc_has_lv(p))
     min_rfree |= 0x38;
   /* compute space needed for local variables in memory */
-  ms = ((max_stack + 31) / 32) * 4;
+  ms = ((max_stack + 31) / 32)* 4;
   /* compute space needed for pushing registers */
   if (no_frame && min_rfree & 0x40)
     push_space += 4;
   if (min_rfree & 0x20)
     push_space += 4;
   if (crt_ret_lab_used) {
 #ifdef NEWDWARF
     long over_lab;
     if (diagnose && dwarf2) {
-      over_lab = next_dwarf_label ();
+      over_lab = next_dwarf_label();
-      dw2_return_pos (over_lab);
+      dw2_return_pos(over_lab);
+    }
 #endif
-    restore_callregs (0);
+    restore_callregs(0);
     retins();
-    outnl ();
+    outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dw2_after_fde_exit (over_lab);
+      dw2_after_fde_exit(over_lab);
 #endif
   };
-  outnl ();
+  outnl();
-  this_pos = ftell (fpout);
+  this_pos = ftell(fpout);
   while (returns_list != nilexp) {
-    st = fseek (fpout, (long)no(returns_list), 0);
+    st = fseek(fpout,(long)no(returns_list), 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
     if (name(returns_list) == 1)
-      out_untidy_pops (tot_sp, push_space);
+      out_untidy_pops(tot_sp, push_space);
     else
-      out_pops(tot_sp, push_space, ptno(returns_list)/8, sonno(returns_list));
+      out_pops(tot_sp, push_space, ptno(returns_list) /8, sonno(returns_list));
     returns_list = bro(returns_list);
   };
   fseek(fpout, this_pos, 0);
   locals_offset = tot_sp;
   if (diagnose) {
     no (p) = tot_sp;	/* may be used by delayed diagnostics */
 #ifdef NEWDWARF
-    DIAG_PROC_END (diag_props, p);
+    DIAG_PROC_END(diag_props, p);
 #else
-    diag_proc_end (diag_props);
+    diag_proc_end(diag_props);
 #endif
 #ifdef NEWDWARF
   if (dwarf2)
-    dw2_complete_fde ();
+    dw2_complete_fde();
 #endif
+  }
   /* now set in the information at the head of the procedure */
+  {
     if (flush_before_tell)
       IGNORE fflush(fpout);
-    this_pos = ftell (fpout);
+    this_pos = ftell(fpout);
-    st = fseek (fpout, old_pos1, 0);
+    st = fseek(fpout, old_pos1, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
     /* set the label which says how much the stack was decreased, in case
        frame pointer addressing is used  */
-    outs (".set ");
+    outs(".set ");
     outs(local_prefix);
-    outs ("disp");
+    outs("disp");
-    outn ((long)crt_proc_id);
+    outn((long)crt_proc_id);
-    outs (", ");
+    outs(", ");
-    outn ((long)tot_sp);
+    outn((long)tot_sp);
     if (ferrsize != 0) {
 	/* set label for displacement to fpu control local store */
-      st = fseek (fpout, old_pos1a, 0);
+      st = fseek(fpout, old_pos1a, 0);
       if (st == -1) {
-        failer (SEEK_FAILURE);
+        failer(SEEK_FAILURE);
         exit(EXIT_FAILURE);
       };
-      outs (".set ");
+      outs(".set ");
       outs(local_prefix);
-      outs ("fcwdisp");
+      outs("fcwdisp");
-      outn ((long)crt_proc_id);
+      outn((long)crt_proc_id);
-      outs (", ");
+      outs(", ");
-      outn ((long)((no_frame) ? (tot_sp - push_space - ferrsize) : (push_space + ferrsize)));
+      outn((long)((no_frame)?(tot_sp - push_space - ferrsize):(push_space + ferrsize)));
+    }
-    st = fseek (fpout, this_pos, 0);
+    st = fseek(fpout, this_pos, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
   };
   if (tot_sp != push_space || proc_has_checkstack(p)) {
     if (flush_before_tell)
       IGNORE fflush(fpout);
-    this_pos = ftell (fpout);
+    this_pos = ftell(fpout);
-    st = fseek (fpout, old_pos8, 0);
+    st = fseek(fpout, old_pos8, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
     /* decrease the stack if necessary */
     if (proc_has_checkstack(p)) {
-      outs (" movl $");
+      outs(" movl $");
-      outn ((long)(tot_sp - push_space));
+      outn((long)(tot_sp - push_space));
-      outs (",%eax");
+      outs(",%eax");
+    }
     else {
-      outs (" subl $");
+      outs(" subl $");
-      outn ((long)(tot_sp - push_space));
+      outn((long)(tot_sp - push_space));
-      outs (",%esp");
+      outs(",%esp");
     };
     outnl();
     if (ferrsize != 0) {	/* record FPU control word */
-      st = fseek (fpout, old_pos9, 0);
+      st = fseek(fpout, old_pos9, 0);
       if (st == -1) {
-        failer (SEEK_FAILURE);
+        failer(SEEK_FAILURE);
         exit(EXIT_FAILURE);
       };
-      move (uwordsh, mw(zeroe, normal_fpucon), mw(ferrmem, 0));
+      move(uwordsh, mw(zeroe, normal_fpucon), mw(ferrmem, 0));
+    }
-    st = fseek (fpout, this_pos, 0);
+    st = fseek(fpout, this_pos, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
   };
   /* push registers as necessary */
   if (min_rfree & 0x8) {
-    st = fseek (fpout, old_pos2, 0);
+    st = fseek(fpout, old_pos2, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
-    outs (" pushl %ebx");
+    outs(" pushl %ebx");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl2 = set_dw_text_label ();
+      dwl2 = set_dw_text_label();
 #endif
   };
   if (min_rfree & 0x10) {
-    st = fseek (fpout, old_pos3, 0);
+    st = fseek(fpout, old_pos3, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
-    outs (" pushl %edi");
+    outs(" pushl %edi");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl3 = set_dw_text_label ();
+      dwl3 = set_dw_text_label();
 #endif
   };
   if (min_rfree & 0x20) {
-    st = fseek (fpout, old_pos4, 0);
+    st = fseek(fpout, old_pos4, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
-    outs (" pushl %esi");
+    outs(" pushl %esi");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl4 = set_dw_text_label ();
+      dwl4 = set_dw_text_label();
 #endif
   };
   if (no_frame && (min_rfree & 0x40)) {
-    st = fseek (fpout, old_pos5, 0);
+    st = fseek(fpout, old_pos5, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
-    outs (" pushl %ebp");
+    outs(" pushl %ebp");
     outnl();
 #ifdef NEWDWARF
     if (diagnose && dwarf2)
-      dwl1 = set_dw_text_label ();
+      dwl1 = set_dw_text_label();
 #endif
   };
 #ifdef NEWDWARF
   if (diagnose && dwarf2) {
-    st = fseek (fpout, dw_entry_pos, 0);
+    st = fseek(fpout, dw_entry_pos, 0);
     if (st == -1) {
-      failer (SEEK_FAILURE);
+      failer(SEEK_FAILURE);
       exit(EXIT_FAILURE);
     };
-    dw2_fde_entry (dwl0, dwl1, dwl2, dwl3, dwl4, dwl8, tot_sp);
+    dw2_fde_entry(dwl0, dwl1, dwl2, dwl3, dwl4, dwl8, tot_sp);
   };
 #endif
-  st = fseek (fpout, this_pos, 0);
+  st = fseek(fpout, this_pos, 0);
   if (st == -1) {
-    failer (SEEK_FAILURE);
+    failer(SEEK_FAILURE);
     exit(EXIT_FAILURE);
   };
-  if (pname[0] != local_prefix[0])
+  if (pname[0]!= local_prefix[0])
-    proc_size (pname);
+    proc_size(pname);
   if (proc_needs_envsize(p)) {
-    outs (".set ");
+    outs(".set ");
     outs(local_prefix);
-    outs ("ESZ");
+    outs("ESZ");
-    outs (pname);
+    outs(pname);
-    outs (", ");
+    outs(", ");
-    outn ((long)(tot_sp + 4 + max_extra_stack/8));
+    outn((long)(tot_sp + 4 + max_extra_stack/8));
-    outnl ();
+    outnl();
+  }
-#if islinux || isfreebsd
+#if isdragonfly || isfreebsd || islinux
   if (
+#if isdragonfly
+  !dragonfly_elf &&
+#elif isfreebsd
+  !freebsd_elf &&
-#if islinux
+#elif islinux
 	!linux_elf &&
 #endif
-	pname[0] != local_prefix[0] &&
+	pname[0]!= local_prefix[0] &&
-	!strcmp (pname+prefix_length, "main")) {
+	!strcmp(pname+prefix_length, "main")) {
     out_main_postlude();
+  }
 #endif
   /* now prepare params with env_offset for possible constant evaluation */
   if (no_frame)			/* hold info for later diagnostics */
     clear_proc_has_fp(p);
   else
     set_proc_has_fp(p);
-  return (proc_needs_envsize(p) ? tot_sp + 4 + max_extra_stack/8 : 0);
+  return(proc_needs_envsize(p)? tot_sp + 4 + max_extra_stack/8 : 0);
+}
 /* Restore call_save registers (%ebp, %esi, %edi, %ebx)
    when we know which ones are reused.
    This preserves %eax, %ecx, %edx */
 void restore_callregs
-    PROTO_N ( (untidy) )
-    PROTO_T ( int untidy )
+(int untidy)
+{
   char *sp50 = "                                                  ";
   long retpos = ftell(fpout);
   outs("?");	/* will be overwritten, to cause assembler fail if sco bug */
   outs(sp50); outs(sp50); outs(sp50);
   outnl();
   returns_list = getexp(f_top, returns_list, 0, nilexp,
-				nilexp, 0, 0, (unsigned char)untidy);
+				nilexp, 0, 0,(unsigned char)untidy);
   no(returns_list) = (int)retpos;
   ptno(returns_list) = stack_dec;
 #ifdef NEWDWARF
   if (diagnose && dwarf2)
-    sonno(returns_list) = (int)dw2_prep_fde_restore_args (untidy);
+    sonno(returns_list) = (int)dw2_prep_fde_restore_args(untidy);
 #endif
   return;
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/installers/80x86/common/cproc.c – Rev 2 → 7