[thirdparty/gcc.git] / gcc / dwarf2asm.c

/* Dwarf2 assembler output helper routines.
   Copyright (C) 2001 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC 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.

GNU CC 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 GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


#include "config.h"
#include "system.h"
#include "flags.h"
#include "rtl.h"
#include "output.h"
#include "dwarf2asm.h"
#include "tm_p.h"


/* How to start an assembler comment.  */
#ifndef ASM_COMMENT_START
#define ASM_COMMENT_START ";#"
#endif

/* Definitions of defaults for assembler-dependent names of various
   pseudo-ops and section names.  These may be overridden in the tm.h
   file (if necessary) for a particular assembler.  */

#ifdef OBJECT_FORMAT_ELF
#ifndef UNALIGNED_SHORT_ASM_OP
#define UNALIGNED_SHORT_ASM_OP		"\t.2byte\t"
#endif
#ifndef UNALIGNED_INT_ASM_OP
#define UNALIGNED_INT_ASM_OP		"\t.4byte\t"
#endif
#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
#define UNALIGNED_DOUBLE_INT_ASM_OP	"\t.8byte\t"
#endif
#endif /* OBJECT_FORMAT_ELF */

#ifndef ASM_BYTE_OP
#define ASM_BYTE_OP			"\t.byte\t"
#endif

/* We don't have unaligned support, let's hope the normal output works for
   .debug_frame.  But we know it won't work for .debug_info.  */
#if !defined(UNALIGNED_INT_ASM_OP) && defined(DWARF2_DEBUGGING_INFO)
 #error DWARF2_DEBUGGING_INFO requires UNALIGNED_INT_ASM_OP.
#endif

\f
#ifdef UNALIGNED_INT_ASM_OP
static const char * unaligned_integer_asm_op  PARAMS ((int));

static inline const char *
unaligned_integer_asm_op (size)
     int size;
{
  const char *op;
  switch (size)
    {
    case 1:
      op = ASM_BYTE_OP;
      break;
    case 2:
      op = UNALIGNED_SHORT_ASM_OP;
      break;
    case 4:
      op = UNALIGNED_INT_ASM_OP;
      break;
    case 8:
#ifdef UNALIGNED_DOUBLE_INT_ASM_OP
      op = UNALIGNED_DOUBLE_INT_ASM_OP;
      break;
#endif
    default:
      abort ();
    }
  return op;
}
#endif /* UNALIGNED_INT_ASM_OP */

/* Output an immediate constant in a given size.  */

void
dw2_asm_output_data VPARAMS ((int size, unsigned HOST_WIDE_INT value,
			      const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  int size;
  unsigned HOST_WIDE_INT value;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  size = va_arg (ap, int);
  value = va_arg (ap, unsigned HOST_WIDE_INT);
  comment = va_arg (ap, const char *);
#endif

#ifdef UNALIGNED_INT_ASM_OP
  fputs (unaligned_integer_asm_op (size), asm_out_file);
  fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
#else
  assemble_integer (GEN_INT (value), size, 1);
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

/* Output the difference between two symbols in a given size.  */
/* ??? There appear to be assemblers that do not like such
   subtraction, but do support ASM_SET_OP.  It's unfortunately
   impossible to do here, since the ASM_SET_OP for the difference
   symbol must appear after both symbols are defined.  */

void
dw2_asm_output_delta VPARAMS ((int size, const char *lab1, const char *lab2,
			       const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  int size;
  const char *lab1, *lab2;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  size = va_arg (ap, int);
  lab1 = va_arg (ap, const char *);
  lab2 = va_arg (ap, const char *);
  comment = va_arg (ap, const char *);
#endif

#ifdef UNALIGNED_INT_ASM_OP
  fputs (unaligned_integer_asm_op (size), asm_out_file);
  assemble_name (asm_out_file, lab1);
  fputc ('-', asm_out_file);
  assemble_name (asm_out_file, lab2);
#else
  assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size, MODE_INT),
				   gen_rtx_SYMBOL_REF (Pmode, lab1),
				   gen_rtx_SYMBOL_REF (Pmode, lab2)),
		    size, 1);
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

/* Output a section-relative reference to a label.  In general this
   can only be done for debugging symbols.  E.g. on most targets with
   the GNU linker, this is accomplished with a direct reference and
   the knowledge that the debugging section will be placed at VMA 0.
   Some targets have special relocations for this that we must use.  */

void
dw2_asm_output_offset VPARAMS ((int size, const char *label,
			       const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  int size;
  const char *label;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  size = va_arg (ap, int);
  label = va_arg (ap, const char *);
  comment = va_arg (ap, const char *);
#endif

#ifdef ASM_OUTPUT_DWARF_OFFSET
  ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label);
#else
#ifdef UNALIGNED_INT_ASM_OP
  fputs (unaligned_integer_asm_op (size), asm_out_file);
  assemble_name (asm_out_file, label);
#else
  assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
#endif
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

/* Output a self-relative reference to a label, possibly in a
   different section or object file.  */

void
dw2_asm_output_pcrel VPARAMS ((int size, const char *label,
			       const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  int size;
  const char *label;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  size = va_arg (ap, int);
  label = va_arg (ap, const char *);
  comment = va_arg (ap, const char *);
#endif

#ifdef ASM_OUTPUT_DWARF_PCREL
  ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
#else
#ifdef UNALIGNED_INT_ASM_OP
  fputs (unaligned_integer_asm_op (size), asm_out_file);
  assemble_name (asm_out_file, label);
  fputc ('-', asm_out_file);
  fputc ('.', asm_out_file);
#else
  abort ();
#endif
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

/* Output an absolute reference to a label.  */

void
dw2_asm_output_addr VPARAMS ((int size, const char *label,
			      const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  int size;
  const char *label;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  size = va_arg (ap, int);
  label = va_arg (ap, const char *);
  comment = va_arg (ap, const char *);
#endif

#ifdef UNALIGNED_INT_ASM_OP
  fputs (unaligned_integer_asm_op (size), asm_out_file);
  assemble_name (asm_out_file, label);
#else
  assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

/* Similar, but use an RTX expression instead of a text label.  */

void
dw2_asm_output_addr_rtx VPARAMS ((int size, rtx addr,
				  const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  int size;
  rtx addr;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  size = va_arg (ap, int);
  addr = va_arg (ap, rtx);
  comment = va_arg (ap, const char *);
#endif

#ifdef UNALIGNED_INT_ASM_OP
  fputs (unaligned_integer_asm_op (size), asm_out_file);
  output_addr_const (asm_out_file, addr);
#else
  assemble_integer (addr, size, 1);
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

void
dw2_asm_output_nstring VPARAMS ((const char *str, size_t orig_len,
				 const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  const char *str;
  size_t orig_len;
  const char *comment;
#endif
  va_list ap;
  size_t i, len = orig_len;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  str = va_arg (ap, const char *);
  len = va_arg (ap, size_t);
  comment = va_arg (ap, const char *);
#endif

  if (len == (size_t) -1)
    len = strlen (str);

  if (flag_debug_asm && comment)
    {
      fputs ("\t.ascii \"", asm_out_file);
      for (i = 0; i < len; i++)
	{
	  int c = str[i];
	  if (c == '\"' || c == '\\')
	    fputc ('\\', asm_out_file);
	  if (ISPRINT(c))
	    fputc (c, asm_out_file);
	  else
	    fprintf (asm_out_file, "\\%o", c);
	}
      fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
      fputc ('\n', asm_out_file);
    }
  else
    {
      /* If an explicit length was given, we can't assume there
	 is a null termination in the string buffer.  */
      if (orig_len == (size_t) -1)
	len += 1;
      ASM_OUTPUT_ASCII (asm_out_file, str, len);
      if (orig_len != (size_t) -1)
	fprintf (asm_out_file, "%s0\n", ASM_BYTE_OP);
    }

  va_end (ap);
}
\f

/* Return the size of an unsigned LEB128 quantity.  */

int
size_of_uleb128 (value)
     unsigned HOST_WIDE_INT value;
{
  int size = 0, byte;

  do
    {
      byte = (value & 0x7f);
      value >>= 7;
      size += 1;
    }
  while (value != 0);

  return size;
}

/* Return the size of a signed LEB128 quantity.  */

int
size_of_sleb128 (value)
     HOST_WIDE_INT value;
{
  int size = 0, byte;

  do
    {
      byte = (value & 0x7f);
      value >>= 7;
      size += 1;
    }
  while (!((value == 0 && (byte & 0x40) == 0)
	   || (value == -1 && (byte & 0x40) != 0)));

  return size;
}

/* Output an unsigned LEB128 quantity.  */

void
dw2_asm_output_data_uleb128 VPARAMS ((unsigned HOST_WIDE_INT value,
				      const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  unsigned HOST_WIDE_INT value;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  value = va_arg (ap, unsigned HOST_WIDE_INT);
  comment = va_arg (ap, const char *);
#endif

#ifdef HAVE_AS_LEB128
  fputs ("\t.uleb128\t", asm_out_file);
  fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
#else
  {
    unsigned HOST_WIDE_INT work = value;

    fputs (ASM_BYTE_OP, asm_out_file);
    do
      {
	int byte = (work & 0x7f);
	work >>= 7;
	if (work != 0)
	  /* More bytes to follow.  */
	  byte |= 0x80;

	fprintf (asm_out_file, "0x%x", byte);
	if (work != 0)
	  fputc (',', asm_out_file);
      }
    while (work != 0);

  if (flag_debug_asm)
    {
      fprintf (asm_out_file, "\t%s uleb128 ", ASM_COMMENT_START);
      fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
      if (comment)
	{
	  fputs ("; ", asm_out_file);
	  vfprintf (asm_out_file, comment, ap);
	}
    }
  }
#endif
  fputc ('\n', asm_out_file);

  va_end (ap);
}

/* Output an signed LEB128 quantity.  */

void
dw2_asm_output_data_sleb128 VPARAMS ((HOST_WIDE_INT value,
				      const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  HOST_WIDE_INT value;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  value = va_arg (ap, HOST_WIDE_INT);
  comment = va_arg (ap, const char *);
#endif

#ifdef HAVE_AS_LEB128
  fputs ("\t.sleb128\t", asm_out_file);
  fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
#else
  {
    HOST_WIDE_INT work = value;
    int more, byte;

    fputs (ASM_BYTE_OP, asm_out_file);
    do
      {
	byte = (work & 0x7f);
	/* arithmetic shift */
	work >>= 7;
	more = !((work == 0 && (byte & 0x40) == 0)
		 || (work == -1 && (byte & 0x40) != 0));
	if (more)
	  byte |= 0x80;

	fprintf (asm_out_file, "0x%x", byte);
	if (more)
	  fputc (',', asm_out_file);
      }
    while (more);

  if (flag_debug_asm)
    {
      fprintf (asm_out_file, "\t%s sleb128 ", ASM_COMMENT_START);
      fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value);
      if (comment)
	{
	  fputs ("; ", asm_out_file);
	  vfprintf (asm_out_file, comment, ap);
	}
    }
  }
#endif
  fputc ('\n', asm_out_file);

  va_end (ap);
}

void
dw2_asm_output_delta_uleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
				       const char *lab2 ATTRIBUTE_UNUSED,
				       const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  const char *lab1, *lab2;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  lab1 = va_arg (ap, const char *);
  lab2 = va_arg (ap, const char *);
  comment = va_arg (ap, const char *);
#endif

#ifdef HAVE_AS_LEB128
  fputs ("\t.uleb128\t", asm_out_file);
  assemble_name (asm_out_file, lab1);
  fputc ('-', asm_out_file);
  assemble_name (asm_out_file, lab2);
#else
  abort ();
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}

void
dw2_asm_output_delta_sleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
				       const char *lab2 ATTRIBUTE_UNUSED,
				       const char *comment, ...))
{
#ifndef ANSI_PROTOTYPES
  const char *lab1, *lab2;
  const char *comment;
#endif
  va_list ap;

  VA_START (ap, comment);

#ifndef ANSI_PROTOTYPES
  lab1 = va_arg (ap, const char *);
  lab2 = va_arg (ap, const char *);
  comment = va_arg (ap, const char *);
#endif

#ifdef HAVE_AS_LEB128
  fputs ("\t.sleb128\t", asm_out_file);
  assemble_name (asm_out_file, lab1);
  fputc ('-', asm_out_file);
  assemble_name (asm_out_file, lab2);
#else
  abort ();
#endif

  if (flag_debug_asm && comment)
    {
      fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
      vfprintf (asm_out_file, comment, ap);
    }
  fputc ('\n', asm_out_file);

  va_end (ap);
}
Commit	Line	Data
2e4b9b8c RH	1	/* Dwarf2 assembler output helper routines.
	2	Copyright (C) 2001 Free Software Foundation, Inc.
	3
	4	This file is part of GNU CC.
	5
	6	GNU CC is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2, or (at your option)
	9	any later version.
	10
	11	GNU CC is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GNU CC; see the file COPYING. If not, write to
	18	the Free Software Foundation, 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21
	22	#include "config.h"
	23	#include "system.h"
	24	#include "flags.h"
	25	#include "rtl.h"
	26	#include "output.h"
	27	#include "dwarf2asm.h"
	28	#include "tm_p.h"
	29
	30
	31	/* How to start an assembler comment. */
	32	#ifndef ASM_COMMENT_START
	33	#define ASM_COMMENT_START ";#"
	34	#endif
	35
	36	/* Definitions of defaults for assembler-dependent names of various
	37	pseudo-ops and section names. These may be overridden in the tm.h
	38	file (if necessary) for a particular assembler. */
	39
	40	#ifdef OBJECT_FORMAT_ELF
	41	#ifndef UNALIGNED_SHORT_ASM_OP
	42	#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t"
	43	#endif
	44	#ifndef UNALIGNED_INT_ASM_OP
	45	#define UNALIGNED_INT_ASM_OP "\t.4byte\t"
	46	#endif
	47	#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
	48	#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t"
	49	#endif
	50	#endif /* OBJECT_FORMAT_ELF */
	51
	52	#ifndef ASM_BYTE_OP
	53	#define ASM_BYTE_OP "\t.byte\t"
	54	#endif
	55
	56	/* We don't have unaligned support, let's hope the normal output works for
	57	.debug_frame. But we know it won't work for .debug_info. */
	58	#if !defined(UNALIGNED_INT_ASM_OP) && defined(DWARF2_DEBUGGING_INFO)
	59	#error DWARF2_DEBUGGING_INFO requires UNALIGNED_INT_ASM_OP.
	60	#endif
	61
	62	\f
	63	#ifdef UNALIGNED_INT_ASM_OP
	64	static const char * unaligned_integer_asm_op PARAMS ((int));
65
66	static inline const char *
67	unaligned_integer_asm_op (size)
68	int size;
69	{
70	const char *op;
71	switch (size)
72	{
73	case 1:
74	op = ASM_BYTE_OP;
75	break;
76	case 2:
77	op = UNALIGNED_SHORT_ASM_OP;
78	break;
79	case 4:
80	op = UNALIGNED_INT_ASM_OP;
81	break;
82	case 8:
83	#ifdef UNALIGNED_DOUBLE_INT_ASM_OP
84	op = UNALIGNED_DOUBLE_INT_ASM_OP;
85	break;
86	#endif
87	default:
88	abort ();
89	}
90	return op;
91	}
92	#endif /* UNALIGNED_INT_ASM_OP */
93
8e7fa2c8 RH	94	/* Output an immediate constant in a given size. */
8e7fa2c8 RH	95
2e4b9b8c RH	96	void
	97	dw2_asm_output_data VPARAMS ((int size, unsigned HOST_WIDE_INT value,
	98	const char *comment, ...))
	99	{
	100	#ifndef ANSI_PROTOTYPES
	101	int size;
	102	unsigned HOST_WIDE_INT value;
	103	const char *comment;
	104	#endif
	105	va_list ap;
	106
	107	VA_START (ap, comment);
	108
	109	#ifndef ANSI_PROTOTYPES
	110	size = va_arg (ap, int);
	111	value = va_arg (ap, unsigned HOST_WIDE_INT);
	112	comment = va_arg (ap, const char *);
	113	#endif
	114
	115	#ifdef UNALIGNED_INT_ASM_OP
	116	fputs (unaligned_integer_asm_op (size), asm_out_file);
	117	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
	118	#else
	119	assemble_integer (GEN_INT (value), size, 1);
	120	#endif
	121
	122	if (flag_debug_asm && comment)
	123	{
	124	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
	125	vfprintf (asm_out_file, comment, ap);
	126	}
	127	fputc ('\n', asm_out_file);
	128
	129	va_end (ap);
	130	}
	131
8e7fa2c8 RH	132	/* Output the difference between two symbols in a given size. */
	133	/* ??? There appear to be assemblers that do not like such
	134	subtraction, but do support ASM_SET_OP. It's unfortunately
	135	impossible to do here, since the ASM_SET_OP for the difference
	136	symbol must appear after both symbols are defined. */
	137
2e4b9b8c RH	138	void
	139	dw2_asm_output_delta VPARAMS ((int size, const char lab1, const char lab2,
	140	const char *comment, ...))
	141	{
	142	#ifndef ANSI_PROTOTYPES
	143	int size;
	144	const char lab1, lab2;
	145	const char *comment;
	146	#endif
	147	va_list ap;
	148
	149	VA_START (ap, comment);
	150
	151	#ifndef ANSI_PROTOTYPES
	152	size = va_arg (ap, int);
	153	lab1 = va_arg (ap, const char *);
	154	lab2 = va_arg (ap, const char *);
	155	comment = va_arg (ap, const char *);
	156	#endif
	157
	158	#ifdef UNALIGNED_INT_ASM_OP
	159	fputs (unaligned_integer_asm_op (size), asm_out_file);
	160	assemble_name (asm_out_file, lab1);
	161	fputc ('-', asm_out_file);
	162	assemble_name (asm_out_file, lab2);
	163	#else
d2f65b7b	164	assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size, MODE_INT),
2e4b9b8c RH	165	gen_rtx_SYMBOL_REF (Pmode, lab1),
	166	gen_rtx_SYMBOL_REF (Pmode, lab2)),
	167	size, 1);
	168	#endif
	169
	170	if (flag_debug_asm && comment)
	171	{
	172	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
	173	vfprintf (asm_out_file, comment, ap);
	174	}
	175	fputc ('\n', asm_out_file);
	176
	177	va_end (ap);
	178	}
	179
8e7fa2c8 RH	180	/* Output a section-relative reference to a label. In general this
	181	can only be done for debugging symbols. E.g. on most targets with
	182	the GNU linker, this is accomplished with a direct reference and
	183	the knowledge that the debugging section will be placed at VMA 0.
	184	Some targets have special relocations for this that we must use. */
	185
2e4b9b8c RH	186	void
	187	dw2_asm_output_offset VPARAMS ((int size, const char *label,
	188	const char *comment, ...))
	189	{
	190	#ifndef ANSI_PROTOTYPES
	191	int size;
	192	const char *label;
	193	const char *comment;
	194	#endif
	195	va_list ap;
	196
	197	VA_START (ap, comment);
	198
	199	#ifndef ANSI_PROTOTYPES
	200	size = va_arg (ap, int);
	201	label = va_arg (ap, const char *);
	202	comment = va_arg (ap, const char *);
	203	#endif
	204
8e7fa2c8 RH	205	#ifdef ASM_OUTPUT_DWARF_OFFSET
	206	ASM_OUTPUT_DWARF_OFFSET (asm_out_file, size, label);
	207	#else
2e4b9b8c RH	208	#ifdef UNALIGNED_INT_ASM_OP
	209	fputs (unaligned_integer_asm_op (size), asm_out_file);
	210	assemble_name (asm_out_file, label);
	211	#else
	212	assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
8e7fa2c8	213	#endif
2e4b9b8c RH	214	#endif
	215
	216	if (flag_debug_asm && comment)
	217	{
	218	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
	219	vfprintf (asm_out_file, comment, ap);
	220	}
	221	fputc ('\n', asm_out_file);
	222
	223	va_end (ap);
	224	}
	225
8e7fa2c8 RH	226	/* Output a self-relative reference to a label, possibly in a
	227	different section or object file. */
	228
2e4b9b8c RH	229	void
	230	dw2_asm_output_pcrel VPARAMS ((int size, const char *label,
	231	const char *comment, ...))
	232	{
	233	#ifndef ANSI_PROTOTYPES
	234	int size;
	235	const char *label;
	236	const char *comment;
	237	#endif
	238	va_list ap;
	239
	240	VA_START (ap, comment);
	241
	242	#ifndef ANSI_PROTOTYPES
	243	size = va_arg (ap, int);
	244	label = va_arg (ap, const char *);
	245	comment = va_arg (ap, const char *);
	246	#endif
	247
8e7fa2c8 RH	248	#ifdef ASM_OUTPUT_DWARF_PCREL
	249	ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, label);
	250	#else
2e4b9b8c RH	251	#ifdef UNALIGNED_INT_ASM_OP
2e4b9b8c RH	252	fputs (unaligned_integer_asm_op (size), asm_out_file);
2e4b9b8c RH	253	assemble_name (asm_out_file, label);
	254	fputc ('-', asm_out_file);
	255	fputc ('.', asm_out_file);
	256	#else
	257	abort ();
	258	#endif
8e7fa2c8 RH	259	#endif
	260
	261	if (flag_debug_asm && comment)
	262	{
	263	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
	264	vfprintf (asm_out_file, comment, ap);
	265	}
	266	fputc ('\n', asm_out_file);
	267
	268	va_end (ap);
	269	}
	270
	271	/* Output an absolute reference to a label. */
	272
	273	void
	274	dw2_asm_output_addr VPARAMS ((int size, const char *label,
	275	const char *comment, ...))
	276	{
	277	#ifndef ANSI_PROTOTYPES
	278	int size;
	279	const char *label;
	280	const char *comment;
	281	#endif
	282	va_list ap;
	283
	284	VA_START (ap, comment);
	285
	286	#ifndef ANSI_PROTOTYPES
	287	size = va_arg (ap, int);
	288	label = va_arg (ap, const char *);
	289	comment = va_arg (ap, const char *);
	290	#endif
	291
	292	#ifdef UNALIGNED_INT_ASM_OP
	293	fputs (unaligned_integer_asm_op (size), asm_out_file);
	294	assemble_name (asm_out_file, label);
	295	#else
	296	assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1);
	297	#endif
2e4b9b8c RH	298
	299	if (flag_debug_asm && comment)
	300	{
	301	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
	302	vfprintf (asm_out_file, comment, ap);
	303	}
	304	fputc ('\n', asm_out_file);
	305
	306	va_end (ap);
	307	}
	308
8e7fa2c8 RH	309	/* Similar, but use an RTX expression instead of a text label. */
8e7fa2c8 RH	310
2e4b9b8c RH	311	void
	312	dw2_asm_output_addr_rtx VPARAMS ((int size, rtx addr,
	313	const char *comment, ...))
	314	{
	315	#ifndef ANSI_PROTOTYPES
	316	int size;
	317	rtx addr;
	318	const char *comment;
	319	#endif
	320	va_list ap;
	321
	322	VA_START (ap, comment);
	323
	324	#ifndef ANSI_PROTOTYPES
	325	size = va_arg (ap, int);
	326	addr = va_arg (ap, rtx);
	327	comment = va_arg (ap, const char *);
	328	#endif
	329
	330	#ifdef UNALIGNED_INT_ASM_OP
	331	fputs (unaligned_integer_asm_op (size), asm_out_file);
	332	output_addr_const (asm_out_file, addr);
	333	#else
	334	assemble_integer (addr, size, 1);
	335	#endif
	336
	337	if (flag_debug_asm && comment)
	338	{
	339	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
	340	vfprintf (asm_out_file, comment, ap);
	341	}
	342	fputc ('\n', asm_out_file);
	343
	344	va_end (ap);
	345	}
	346
	347	void
	348	dw2_asm_output_nstring VPARAMS ((const char *str, size_t orig_len,
	349	const char *comment, ...))
	350	{
	351	#ifndef ANSI_PROTOTYPES
	352	const char *str;
	353	size_t orig_len;
	354	const char *comment;
	355	#endif
	356	va_list ap;
	357	size_t i, len = orig_len;
	358
	359	VA_START (ap, comment);
	360
	361	#ifndef ANSI_PROTOTYPES
	362	str = va_arg (ap, const char *);
	363	len = va_arg (ap, size_t);
	364	comment = va_arg (ap, const char *);
	365	#endif
	366
	367	if (len == (size_t) -1)
	368	len = strlen (str);
	369
	370	if (flag_debug_asm && comment)
	371	{
	372	fputs ("\t.ascii \"", asm_out_file);
	373	for (i = 0; i < len; i++)
	374	{
375	int c = str[i];
376	if (c == '\"' \|\| c == '\\')
377	fputc ('\\', asm_out_file);
378	if (ISPRINT(c))
379	fputc (c, asm_out_file);
380	else
381	fprintf (asm_out_file, "\\%o", c);
382	}
383	fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START);
384	vfprintf (asm_out_file, comment, ap);
385	fputc ('\n', asm_out_file);
386	}
387	else
388	{
389	/* If an explicit length was given, we can't assume there
390	is a null termination in the string buffer. */
391	if (orig_len == (size_t) -1)
392	len += 1;
393	ASM_OUTPUT_ASCII (asm_out_file, str, len);
394	if (orig_len != (size_t) -1)
395	fprintf (asm_out_file, "%s0\n", ASM_BYTE_OP);
396	}
397
398	va_end (ap);
399	}
400	\f
401
402	/* Return the size of an unsigned LEB128 quantity. */
403
404	int
405	size_of_uleb128 (value)
406	unsigned HOST_WIDE_INT value;
407	{
408	int size = 0, byte;
409
410	do
411	{
412	byte = (value & 0x7f);
413	value >>= 7;
414	size += 1;
415	}
416	while (value != 0);
417
418	return size;
419	}
420
421	/* Return the size of a signed LEB128 quantity. */
422
423	int
424	size_of_sleb128 (value)
425	HOST_WIDE_INT value;
426	{
427	int size = 0, byte;
428
429	do
430	{
431	byte = (value & 0x7f);
432	value >>= 7;
433	size += 1;
434	}
435	while (!((value == 0 && (byte & 0x40) == 0)
436	\|\| (value == -1 && (byte & 0x40) != 0)));
437
438	return size;
439	}
440
441	/* Output an unsigned LEB128 quantity. */
442
443	void
444	dw2_asm_output_data_uleb128 VPARAMS ((unsigned HOST_WIDE_INT value,
445	const char *comment, ...))
446	{
447	#ifndef ANSI_PROTOTYPES
448	unsigned HOST_WIDE_INT value;
449	const char *comment;
450	#endif
451	va_list ap;
452
453	VA_START (ap, comment);
454
455	#ifndef ANSI_PROTOTYPES
456	value = va_arg (ap, unsigned HOST_WIDE_INT);
457	comment = va_arg (ap, const char *);
458	#endif
459
460	#ifdef HAVE_AS_LEB128
461	fputs ("\t.uleb128\t", asm_out_file);
462	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
463
464	if (flag_debug_asm && comment)
465	{
466	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
467	vfprintf (asm_out_file, comment, ap);
468	}
469	#else
470	{
471	unsigned HOST_WIDE_INT work = value;
472
473	fputs (ASM_BYTE_OP, asm_out_file);
474	do
475	{
476	int byte = (work & 0x7f);
477	work >>= 7;
478	if (work != 0)
479	/* More bytes to follow. */
480	byte \|= 0x80;
481
482	fprintf (asm_out_file, "0x%x", byte);
483	if (work != 0)
484	fputc (',', asm_out_file);
485	}
486	while (work != 0);
487
488	if (flag_debug_asm)
489	{
490	fprintf (asm_out_file, "\t%s uleb128 ", ASM_COMMENT_START);
491	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
492	if (comment)
493	{
494	fputs ("; ", asm_out_file);
495	vfprintf (asm_out_file, comment, ap);
496	}
497	}
498	}
499	#endif
500	fputc ('\n', asm_out_file);
501
502	va_end (ap);
503	}
504
505	/* Output an signed LEB128 quantity. */
506
507	void
508	dw2_asm_output_data_sleb128 VPARAMS ((HOST_WIDE_INT value,
509	const char *comment, ...))
510	{
511	#ifndef ANSI_PROTOTYPES
512	HOST_WIDE_INT value;
513	const char *comment;
514	#endif
515	va_list ap;
516
517	VA_START (ap, comment);
518
519	#ifndef ANSI_PROTOTYPES
520	value = va_arg (ap, HOST_WIDE_INT);
521	comment = va_arg (ap, const char *);
522	#endif
523
524	#ifdef HAVE_AS_LEB128
525	fputs ("\t.sleb128\t", asm_out_file);
526	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value);
527
528	if (flag_debug_asm && comment)
529	{
530	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
531	vfprintf (asm_out_file, comment, ap);
532	}
533	#else
534	{
535	HOST_WIDE_INT work = value;
536	int more, byte;
537
538	fputs (ASM_BYTE_OP, asm_out_file);
539	do
540	{
541	byte = (work & 0x7f);
542	/* arithmetic shift */
543	work >>= 7;
544	more = !((work == 0 && (byte & 0x40) == 0)
545	\|\| (work == -1 && (byte & 0x40) != 0));
546	if (more)
547	byte \|= 0x80;
548
549	fprintf (asm_out_file, "0x%x", byte);
550	if (more)
551	fputc (',', asm_out_file);
552	}
553	while (more);
554
555	if (flag_debug_asm)
556	{
557	fprintf (asm_out_file, "\t%s sleb128 ", ASM_COMMENT_START);
558	fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value);
559	if (comment)
560	{
561	fputs ("; ", asm_out_file);
562	vfprintf (asm_out_file, comment, ap);
563	}
564	}
565	}
566	#endif
567	fputc ('\n', asm_out_file);
568
569	va_end (ap);
570	}
571
572	void
573	dw2_asm_output_delta_uleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
574	const char *lab2 ATTRIBUTE_UNUSED,
575	const char *comment, ...))
576	{
577	#ifndef ANSI_PROTOTYPES
578	const char lab1, lab2;
579	const char *comment;
580	#endif
581	va_list ap;
582
583	VA_START (ap, comment);
584
585	#ifndef ANSI_PROTOTYPES
586	lab1 = va_arg (ap, const char *);
587	lab2 = va_arg (ap, const char *);
588	comment = va_arg (ap, const char *);
589	#endif
590
591	#ifdef HAVE_AS_LEB128
592	fputs ("\t.uleb128\t", asm_out_file);
593	assemble_name (asm_out_file, lab1);
594	fputc ('-', asm_out_file);
595	assemble_name (asm_out_file, lab2);
596	#else
597	abort ();
598	#endif
599
600	if (flag_debug_asm && comment)
601	{
602	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
603	vfprintf (asm_out_file, comment, ap);
604	}
605	fputc ('\n', asm_out_file);
606
607	va_end (ap);
608	}
609
610	void
611	dw2_asm_output_delta_sleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED,
612	const char *lab2 ATTRIBUTE_UNUSED,
613	const char *comment, ...))
614	{
615	#ifndef ANSI_PROTOTYPES
616	const char lab1, lab2;
617	const char *comment;
618	#endif
619	va_list ap;
620
621	VA_START (ap, comment);
622
623	#ifndef ANSI_PROTOTYPES
624	lab1 = va_arg (ap, const char *);
625	lab2 = va_arg (ap, const char *);
626	comment = va_arg (ap, const char *);
627	#endif
628
629	#ifdef HAVE_AS_LEB128
630	fputs ("\t.sleb128\t", asm_out_file);
631	assemble_name (asm_out_file, lab1);
632	fputc ('-', asm_out_file);
633	assemble_name (asm_out_file, lab2);
634	#else
635	abort ();
636	#endif
637
638	if (flag_debug_asm && comment)
639	{
640	fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
641	vfprintf (asm_out_file, comment, ap);
642	}
643	fputc ('\n', asm_out_file);
644
645	va_end (ap);
646	}