[binutils.git] / gas / ehopt.c

/* ehopt.c--optimize gcc exception frame information.
   Copyright (C) 1998 Free Software Foundation, Inc.
   Written by Ian Lance Taylor <[email protected]>.

This file is part of GAS, the GNU Assembler.

GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GAS; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */

#include "as.h"
#include "subsegs.h"

/* We include this ELF file, even though we may not be assembling for
   ELF, since the exception frame information is always in a format
   derived from DWARF.  */

#include "elf/dwarf2.h"

/* Try to optimize gcc 2.8 exception frame information.

   Exception frame information is emitted for every function in the
   .eh_frame section.  Simple information for a function with no
   exceptions looks like this:

__FRAME_BEGIN__:
	.4byte	.LLCIE1	/ Length of Common Information Entry
.LSCIE1:
	.4byte	0x0	/ CIE Identifier Tag
	.byte	0x1	/ CIE Version
	.byte	0x0	/ CIE Augmentation (none)
	.byte	0x1	/ ULEB128 0x1 (CIE Code Alignment Factor)
	.byte	0x7c	/ SLEB128 -4 (CIE Data Alignment Factor)
	.byte	0x8	/ CIE RA Column
	.byte	0xc	/ DW_CFA_def_cfa
	.byte	0x4	/ ULEB128 0x4
	.byte	0x4	/ ULEB128 0x4
	.byte	0x88	/ DW_CFA_offset, column 0x8
	.byte	0x1	/ ULEB128 0x1
	.align 4
.LECIE1:
	.set	.LLCIE1,.LECIE1-.LSCIE1	/ CIE Length Symbol
	.4byte	.LLFDE1	/ FDE Length
.LSFDE1:
	.4byte	.LSFDE1-__FRAME_BEGIN__	/ FDE CIE offset
	.4byte	.LFB1	/ FDE initial location
	.4byte	.LFE1-.LFB1	/ FDE address range
	.byte	0x4	/ DW_CFA_advance_loc4
	.4byte	.LCFI0-.LFB1
	.byte	0xe	/ DW_CFA_def_cfa_offset
	.byte	0x8	/ ULEB128 0x8
	.byte	0x85	/ DW_CFA_offset, column 0x5
	.byte	0x2	/ ULEB128 0x2
	.byte	0x4	/ DW_CFA_advance_loc4
	.4byte	.LCFI1-.LCFI0
	.byte	0xd	/ DW_CFA_def_cfa_register
	.byte	0x5	/ ULEB128 0x5
	.byte	0x4	/ DW_CFA_advance_loc4
	.4byte	.LCFI2-.LCFI1
	.byte	0x2e	/ DW_CFA_GNU_args_size
	.byte	0x4	/ ULEB128 0x4
	.byte	0x4	/ DW_CFA_advance_loc4
	.4byte	.LCFI3-.LCFI2
	.byte	0x2e	/ DW_CFA_GNU_args_size
	.byte	0x0	/ ULEB128 0x0
	.align 4
.LEFDE1:
	.set	.LLFDE1,.LEFDE1-.LSFDE1	/ FDE Length Symbol

   The immediate issue we can address in the assembler is the
   DW_CFA_advance_loc4 followed by a four byte value.  The value is
   the difference of two addresses in the function.  Since gcc does
   not know this value, it always uses four bytes.  We will know the
   value at the end of assembly, so we can do better.  */

static int eh_frame_code_alignment PARAMS ((void));

/* Get the code alignment factor from the CIE.  */

static int
eh_frame_code_alignment ()
{
  static int code_alignment;
  segT current_seg;
  subsegT current_subseg;
  fragS *f;
  int offset;

  if (code_alignment != 0)
    return code_alignment;

  /* We should find the CIE at the start of the .eh_frame section.  */

  current_seg = now_seg;
  current_subseg = now_subseg;
  subseg_new (".eh_frame", 0);
  f = seg_info (now_seg)->frchainP->frch_root;
  subseg_set (current_seg, current_subseg);

  /* Look through the frags of the section to find the code alignment.  */

  /* First make sure that the CIE Identifier Tag is 0.  */

  offset = 4;
  while (f != NULL && offset >= f->fr_fix)
    {
      offset -= f->fr_fix;
      f = f->fr_next;
    }
  if (f == NULL
      || f->fr_fix - offset < 4
      || f->fr_literal[offset] != 0
      || f->fr_literal[offset + 1] != 0
      || f->fr_literal[offset + 2] != 0
      || f->fr_literal[offset + 3] != 0)
    {
      code_alignment = -1;
      return -1;
    }

  /* Next make sure the CIE version number is 1.  */

  offset += 4;
  while (f != NULL && offset >= f->fr_fix)
    {
      offset -= f->fr_fix;
      f = f->fr_next;
    }
  if (f == NULL
      || f->fr_fix - offset < 1
      || f->fr_literal[offset] != 1)
    {
      code_alignment = -1;
      return -1;
    }

  /* Skip the augmentation (a null terminated string).  */

  ++offset;
  while (1)
    {
      while (f != NULL && offset >= f->fr_fix)
	{
	  offset -= f->fr_fix;
	  f = f->fr_next;
	}
      if (f == NULL)
	{
	  code_alignment = -1;
	  return -1;
	}
      while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
	++offset;
      if (offset < f->fr_fix)
	break;
    }
  ++offset;
  while (f != NULL && offset >= f->fr_fix)
    {
      offset -= f->fr_fix;
      f = f->fr_next;
    }
  if (f == NULL)
    {
      code_alignment = -1;
      return -1;
    }

  /* We're now at the code alignment factor, which is a ULEB128.  If
     it isn't a single byte, forget it.  */

  code_alignment = f->fr_literal[offset] & 0xff;
  if ((code_alignment & 0x80) != 0 || code_alignment == 0)
    {
      code_alignment = -1;
      return -1;
    }

  return code_alignment;
}

/* This function is called from emit_expr.  It looks for cases which
   we can optimize.

   Rather than try to parse all this information as we read it, we
   look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
   difference.  We turn that into a rs_cfa_advance frag, and handle
   those frags at the end of the assembly.  If the gcc output changes
   somewhat, this optimization may stop working.

   This function returns non-zero if it handled the expression and
   emit_expr should not do anything, or zero otherwise.  It can also
   change *EXP and *PNBYTES.  */

int
check_eh_frame (exp, pnbytes)
     expressionS *exp;
     unsigned int *pnbytes;
{
  static int saw_advance_loc4;
  static fragS *loc4_frag;
  static int loc4_fix;

  if (flag_traditional_format)
    {
      /* Don't optimize.  */
    }
  else if (strcmp (segment_name (now_seg), ".eh_frame") != 0)
    saw_advance_loc4 = 0;
  else if (*pnbytes == 1
	   && exp->X_op == O_constant
	   && exp->X_add_number == DW_CFA_advance_loc4)
    {
      /* This might be a DW_CFA_advance_loc4.  Record the frag and the
         position within the frag, so that we can change it later.  */
      saw_advance_loc4 = 1;
      frag_grow (1);
      loc4_frag = frag_now;
      loc4_fix = frag_now_fix ();
    }
  else if (saw_advance_loc4
	   && *pnbytes == 4
	   && exp->X_op == O_constant)
    {
      int ca;

      /* This is a case which we can optimize.  The two symbols being
         subtracted were in the same frag and the expression was
         reduced to a constant.  We can do the optimization entirely
         in this function.  */

      saw_advance_loc4 = 0;

      ca = eh_frame_code_alignment ();
      if (ca < 0)
	{
	  /* Don't optimize.  */
	}
      else if (exp->X_add_number % ca == 0
	  && exp->X_add_number / ca < 0x40)
	{
	  loc4_frag->fr_literal[loc4_fix]
	    = DW_CFA_advance_loc | (exp->X_add_number / ca);
	  /* No more bytes needed.  */
	  return 1;
	}
      else if (exp->X_add_number < 0x100)
	{
	  loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
	  *pnbytes = 1;
	}
      else if (exp->X_add_number < 0x10000)
	{
	  loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
	  *pnbytes = 2;
	}
    }
  else if (saw_advance_loc4
	   && *pnbytes == 4
	   && exp->X_op == O_subtract)
    {

      /* This is a case we can optimize.  The expression was not
         reduced, so we can not finish the optimization until the end
         of the assembly.  We set up a variant frag which we handle
         later.  */

      saw_advance_loc4 = 0;

      frag_var (rs_cfa, 4, 0, 0, make_expr_symbol (exp),
		loc4_fix, (char *) loc4_frag);
    }
  else
    saw_advance_loc4 = 0;

  return 0;
}

/* The function estimates the size of a rs_cfa variant frag based on
   the current values of the symbols.  It is called before the
   relaxation loop.  We set fr_subtype to the expected length.  */

int
eh_frame_estimate_size_before_relax (frag)
     fragS *frag;
{
  int ca;
  offsetT diff;
  int ret;

  ca = eh_frame_code_alignment ();
  diff = resolve_symbol_value (frag->fr_symbol, 0);

  if (ca < 0)
    ret = 4;
  else if (diff % ca == 0 && diff / ca < 0x40)
    ret = 0;
  else if (diff < 0x100)
    ret = 1;
  else if (diff < 0x10000)
    ret = 2;
  else
    ret = 4;

  frag->fr_subtype = ret;

  return ret;
}

/* This function relaxes a rs_cfa variant frag based on the current
   values of the symbols.  fr_subtype is the current length of the
   frag.  This returns the change in frag length.  */

int
eh_frame_relax_frag (frag)
     fragS *frag;
{
  int oldsize, newsize;

  oldsize = frag->fr_subtype;
  newsize = eh_frame_estimate_size_before_relax (frag);
  return newsize - oldsize;
}

/* This function converts a rs_cfa variant frag into a normal fill
   frag.  This is called after all relaxation has been done.
   fr_subtype will be the desired length of the frag.  */

void
eh_frame_convert_frag (frag)
     fragS *frag;
{
  offsetT diff;
  fragS *loc4_frag;
  int loc4_fix;

  loc4_frag = (fragS *) frag->fr_opcode;
  loc4_fix = (int) frag->fr_offset;

  diff = resolve_symbol_value (frag->fr_symbol, 1);

  if (frag->fr_subtype == 0)
    {
      int ca;

      ca = eh_frame_code_alignment ();
      assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
      loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | (diff / ca);
    }
  else if (frag->fr_subtype == 1)
    {
      assert (diff < 0x100);
      loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
      frag->fr_literal[frag->fr_fix] = diff;
    }
  else if (frag->fr_subtype == 2)
    {
      assert (diff < 0x10000);
      loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
      md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
    }
  else
    md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);

  frag->fr_fix += frag->fr_subtype;
  frag->fr_type = rs_fill;
}
Commit	Line	Data
ffd652c3 ILT	1	/* ehopt.c--optimize gcc exception frame information.
	2	Copyright (C) 1998 Free Software Foundation, Inc.
	3	Written by Ian Lance Taylor <[email protected]>.
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GAS is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	20	02111-1307, USA. */
	21
	22	#include "as.h"
	23	#include "subsegs.h"
	24
	25	/* We include this ELF file, even though we may not be assembling for
	26	ELF, since the exception frame information is always in a format
	27	derived from DWARF. */
	28
	29	#include "elf/dwarf2.h"
	30
	31	/* Try to optimize gcc 2.8 exception frame information.
	32
	33	Exception frame information is emitted for every function in the
	34	.eh_frame section. Simple information for a function with no
	35	exceptions looks like this:
	36
	37	__FRAME_BEGIN__:
	38	.4byte .LLCIE1 / Length of Common Information Entry
	39	.LSCIE1:
	40	.4byte 0x0 / CIE Identifier Tag
	41	.byte 0x1 / CIE Version
	42	.byte 0x0 / CIE Augmentation (none)
	43	.byte 0x1 / ULEB128 0x1 (CIE Code Alignment Factor)
	44	.byte 0x7c / SLEB128 -4 (CIE Data Alignment Factor)
	45	.byte 0x8 / CIE RA Column
	46	.byte 0xc / DW_CFA_def_cfa
	47	.byte 0x4 / ULEB128 0x4
	48	.byte 0x4 / ULEB128 0x4
	49	.byte 0x88 / DW_CFA_offset, column 0x8
	50	.byte 0x1 / ULEB128 0x1
	51	.align 4
	52	.LECIE1:
	53	.set .LLCIE1,.LECIE1-.LSCIE1 / CIE Length Symbol
	54	.4byte .LLFDE1 / FDE Length
	55	.LSFDE1:
	56	.4byte .LSFDE1-__FRAME_BEGIN__ / FDE CIE offset
	57	.4byte .LFB1 / FDE initial location
	58	.4byte .LFE1-.LFB1 / FDE address range
	59	.byte 0x4 / DW_CFA_advance_loc4
	60	.4byte .LCFI0-.LFB1
	61	.byte 0xe / DW_CFA_def_cfa_offset
	62	.byte 0x8 / ULEB128 0x8
	63	.byte 0x85 / DW_CFA_offset, column 0x5
	64	.byte 0x2 / ULEB128 0x2
65	.byte 0x4 / DW_CFA_advance_loc4
66	.4byte .LCFI1-.LCFI0
67	.byte 0xd / DW_CFA_def_cfa_register
68	.byte 0x5 / ULEB128 0x5
69	.byte 0x4 / DW_CFA_advance_loc4
70	.4byte .LCFI2-.LCFI1
71	.byte 0x2e / DW_CFA_GNU_args_size
72	.byte 0x4 / ULEB128 0x4
73	.byte 0x4 / DW_CFA_advance_loc4
74	.4byte .LCFI3-.LCFI2
75	.byte 0x2e / DW_CFA_GNU_args_size
76	.byte 0x0 / ULEB128 0x0
77	.align 4
78	.LEFDE1:
79	.set .LLFDE1,.LEFDE1-.LSFDE1 / FDE Length Symbol
80
81	The immediate issue we can address in the assembler is the
82	DW_CFA_advance_loc4 followed by a four byte value. The value is
83	the difference of two addresses in the function. Since gcc does
84	not know this value, it always uses four bytes. We will know the
85	value at the end of assembly, so we can do better. */
86
87	static int eh_frame_code_alignment PARAMS ((void));
88
89	/* Get the code alignment factor from the CIE. */
90
91	static int
92	eh_frame_code_alignment ()
93	{
94	static int code_alignment;
95	segT current_seg;
96	subsegT current_subseg;
97	fragS *f;
98	int offset;
99
100	if (code_alignment != 0)
101	return code_alignment;
102
103	/* We should find the CIE at the start of the .eh_frame section. */
104
105	current_seg = now_seg;
106	current_subseg = now_subseg;
107	subseg_new (".eh_frame", 0);
108	f = seg_info (now_seg)->frchainP->frch_root;
109	subseg_set (current_seg, current_subseg);
110
111	/* Look through the frags of the section to find the code alignment. */
112
113	/* First make sure that the CIE Identifier Tag is 0. */
114
115	offset = 4;
116	while (f != NULL && offset >= f->fr_fix)
117	{
118	offset -= f->fr_fix;
119	f = f->fr_next;
120	}
121	if (f == NULL
122	\|\| f->fr_fix - offset < 4
123	\|\| f->fr_literal[offset] != 0
124	\|\| f->fr_literal[offset + 1] != 0
125	\|\| f->fr_literal[offset + 2] != 0
126	\|\| f->fr_literal[offset + 3] != 0)
127	{
128	code_alignment = -1;
129	return -1;
130	}
131
132	/* Next make sure the CIE version number is 1. */
133
134	offset += 4;
135	while (f != NULL && offset >= f->fr_fix)
136	{
137	offset -= f->fr_fix;
138	f = f->fr_next;
139	}
140	if (f == NULL
141	\|\| f->fr_fix - offset < 1
142	\|\| f->fr_literal[offset] != 1)
143	{
144	code_alignment = -1;
145	return -1;
146	}
147
148	/* Skip the augmentation (a null terminated string). */
149
150	++offset;
151	while (1)
152	{
153	while (f != NULL && offset >= f->fr_fix)
154	{
155	offset -= f->fr_fix;
156	f = f->fr_next;
157	}
158	if (f == NULL)
159	{
160	code_alignment = -1;
161	return -1;
162	}
163	while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
164	++offset;
165	if (offset < f->fr_fix)
166	break;
167	}
168	++offset;
169	while (f != NULL && offset >= f->fr_fix)
170	{
171	offset -= f->fr_fix;
172	f = f->fr_next;
173	}
174	if (f == NULL)
175	{
176	code_alignment = -1;
177	return -1;
178	}
179
180	/* We're now at the code alignment factor, which is a ULEB128. If
181	it isn't a single byte, forget it. */
182
183	code_alignment = f->fr_literal[offset] & 0xff;
184	if ((code_alignment & 0x80) != 0 \|\| code_alignment == 0)
185	{
186	code_alignment = -1;
187	return -1;
188	}
189
190	return code_alignment;
191	}
192
193	/* This function is called from emit_expr. It looks for cases which
194	we can optimize.
195
196	Rather than try to parse all this information as we read it, we
197	look for a single byte DW_CFA_advance_loc4 followed by a 4 byte
198	difference. We turn that into a rs_cfa_advance frag, and handle
199	those frags at the end of the assembly. If the gcc output changes
200	somewhat, this optimization may stop working.
201
202	This function returns non-zero if it handled the expression and
203	emit_expr should not do anything, or zero otherwise. It can also
204	change EXP and PNBYTES. */
205
206	int
207	check_eh_frame (exp, pnbytes)
208	expressionS *exp;
209	unsigned int *pnbytes;
210	{
211	static int saw_advance_loc4;
212	static fragS *loc4_frag;
213	static int loc4_fix;
214
215	if (flag_traditional_format)
216	{
217	/* Don't optimize. */
218	}
219	else if (strcmp (segment_name (now_seg), ".eh_frame") != 0)
220	saw_advance_loc4 = 0;
221	else if (*pnbytes == 1
222	&& exp->X_op == O_constant
223	&& exp->X_add_number == DW_CFA_advance_loc4)
224	{
225	/* This might be a DW_CFA_advance_loc4. Record the frag and the
226	position within the frag, so that we can change it later. */
227	saw_advance_loc4 = 1;
228	frag_grow (1);
229	loc4_frag = frag_now;
230	loc4_fix = frag_now_fix ();
231	}
232	else if (saw_advance_loc4
233	&& *pnbytes == 4
234	&& exp->X_op == O_constant)
235	{
236	int ca;
237
238	/* This is a case which we can optimize. The two symbols being
239	subtracted were in the same frag and the expression was
240	reduced to a constant. We can do the optimization entirely
241	in this function. */
242
243	saw_advance_loc4 = 0;
244
245	ca = eh_frame_code_alignment ();
246	if (ca < 0)
247	{
248	/* Don't optimize. */
249	}
250	else if (exp->X_add_number % ca == 0
251	&& exp->X_add_number / ca < 0x40)
252	{
253	loc4_frag->fr_literal[loc4_fix]
254	= DW_CFA_advance_loc \| (exp->X_add_number / ca);
255	/* No more bytes needed. */
256	return 1;
257	}
258	else if (exp->X_add_number < 0x100)
259	{
260	loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
261	*pnbytes = 1;
262	}
263	else if (exp->X_add_number < 0x10000)
264	{
265	loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
266	*pnbytes = 2;
267	}
268	}
269	else if (saw_advance_loc4
270	&& *pnbytes == 4
271	&& exp->X_op == O_subtract)
272	{
273
274	/* This is a case we can optimize. The expression was not
275	reduced, so we can not finish the optimization until the end
276	of the assembly. We set up a variant frag which we handle
277	later. */
278
279	saw_advance_loc4 = 0;
280
281	frag_var (rs_cfa, 4, 0, 0, make_expr_symbol (exp),
282	loc4_fix, (char *) loc4_frag);
283	}
284	else
285	saw_advance_loc4 = 0;
286
287	return 0;
288	}
289
290	/* The function estimates the size of a rs_cfa variant frag based on
291	the current values of the symbols. It is called before the
292	relaxation loop. We set fr_subtype to the expected length. */
293
294	int
295	eh_frame_estimate_size_before_relax (frag)
296	fragS *frag;
297	{
298	int ca;
299	offsetT diff;
300	int ret;
301
302	ca = eh_frame_code_alignment ();
303	diff = resolve_symbol_value (frag->fr_symbol, 0);
304
305	if (ca < 0)
306	ret = 4;
307	else if (diff % ca == 0 && diff / ca < 0x40)
308	ret = 0;
309	else if (diff < 0x100)
310	ret = 1;
311	else if (diff < 0x10000)
312	ret = 2;
313	else
314	ret = 4;
315
316	frag->fr_subtype = ret;
317
318	return ret;
319	}
320
321	/* This function relaxes a rs_cfa variant frag based on the current
322	values of the symbols. fr_subtype is the current length of the
323	frag. This returns the change in frag length. */
324
325	int
326	eh_frame_relax_frag (frag)
327	fragS *frag;
328	{
329	int oldsize, newsize;
330
331	oldsize = frag->fr_subtype;
332	newsize = eh_frame_estimate_size_before_relax (frag);
333	return newsize - oldsize;
334	}
335
336	/* This function converts a rs_cfa variant frag into a normal fill
337	frag. This is called after all relaxation has been done.
338	fr_subtype will be the desired length of the frag. */
339
340	void
341	eh_frame_convert_frag (frag)
342	fragS *frag;
343	{
344	offsetT diff;
345	fragS *loc4_frag;
346	int loc4_fix;
347
348	loc4_frag = (fragS *) frag->fr_opcode;
349	loc4_fix = (int) frag->fr_offset;
350
351	diff = resolve_symbol_value (frag->fr_symbol, 1);
352
353	if (frag->fr_subtype == 0)
354	{
355	int ca;
356
357	ca = eh_frame_code_alignment ();
358	assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
359	loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc \| (diff / ca);
360	}
361	else if (frag->fr_subtype == 1)
362	{
363	assert (diff < 0x100);
364	loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
365	frag->fr_literal[frag->fr_fix] = diff;
366	}
367	else if (frag->fr_subtype == 2)
368	{
369	assert (diff < 0x10000);
370	loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
371	md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
372	}
373	else
374	md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
375
376	frag->fr_fix += frag->fr_subtype;
377	frag->fr_type = rs_fill;
378	}