path: root/gprofng/src/comp_com.h

/* Copyright (C) 2021-2023 Free Software Foundation, Inc.
   Contributed by Oracle.

   This file is part of GNU Binutils.

   This program 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 3, or (at your option)
   any later version.

   This program 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 this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#ifndef _COMP_COM_H
#define _COMP_COM_H

#include <sys/types.h>
#include <nl_types.h>

/*
 * This file describes format for the compiler-commentary
 * section to be added to .o's and propagated to the a.out.  It reflects
 * information the compiler can expose to the user about his or her
 * program.  The section should be generated for all compiles where
 * the user has specified -g on the compile line.
 *
 * In the analyzer, display of the messages will be governed by a user UI
 * that sets a vis_bits bitmap, and matches it against a show_bits
 * bitmap table, which is maintained separately from the producer
 * code.  For any message, if (vis_bits&show_bits) is  non-zero, the
 * message is shown.  If zero, the message is not shown.  A similar
 * mechanism would be used for a stand-alone source or disassembly browser.
 *
 *
 * The .compcom Section
 * --------------------
 * The section will be named ".compcom"; it is generated for each
 * .o, and aggregated into a single section in the a.out.  In that
 * section, each .o's data is separate, and the tools will loop
 * over the data for each .o in order to find the subsection for
 * the particular .o being annotated.
 *
 *
 * Since the header is fixed-length, and the total size of the section
 * can be easily determined as:
 *
 *     sizeof(stuct compcomhdr)
 * 	+ msgcount * sizeof(struct compmsg)
 * 	+ paramcount * sizeof(int32_t)
 * 	+ stringlen
 *
 * there is no need to have the size in the header.
 */

typedef struct
{ /* Header describing the section */
  int32_t srcname;          /* index into strings of source file path */
  int32_t version;          /* a version number for the .compcom format */
  int32_t msgcount;         /* count of messages in the section */
  int32_t paramcount;       /* count of parameters in the section */
  int32_t stringcount;      /* count of strings in the section */
  int32_t stringlen;        /* count of total bytes in strings */
} compcomhdr;

/*
 * The data for the .o after the header as:
 *
 *    compmsg	msgs[msgcount];		the array of messages
 *    int32_t	param[paramcount];	the parameters used in the messages
 *					parameters are either integers or
 *					string-indices
 *    char	msgstrings[stringlen];	the strings used in the messages
 */

/*
 * Message Classes and Visualization Bits
 * --------------------------------------
 * Each of the messages above may belong to zero or more visualization
 * classes, governed by a table using zero or more of the following symbolic
 * names for the classes:
 */
typedef enum {
CCMV_WANT   = 0x000,		/* High-priority RFE -- used only for human */
				/*   reading of message list */
CCMV_UNIMPL = 0x000,		/* Unimplemented -- used only for human */
				/*   reading of message list */
CCMV_OBS    = 0x000,		/* Obsolete -- to be replaced by a different */
				/*   message with different parameters -- */
				/*   used only for human reading of message */
				/*   list */
CCMV_VER    = 0x001,		/* Versioning messages */
CCMV_WARN   = 0x002,		/* Warning messages */
CCMV_PAR    = 0x004,		/* Parallelization messages */
CCMV_QUERY  = 0x008,		/* Compiler queries */
CCMV_LOOP   = 0x010,		/* Loop detail messages */
CCMV_PIPE   = 0x020,		/* Pipelining messages */
CCMV_INLINE = 0x040,		/* Inlining information */
CCMV_MEMOPS = 0x080,		/* Messages concerning memory operations */
CCMV_FE     = 0x100,		/* Front-end messages (all compilers) */
CCMV_CG     = 0x200,		/* Code-generator messages (all compilers) */
CCMV_BASIC  = 0x400,		/* for default messages */
CCMV_ALL    = 0x7FFFFFFF	/* for all messages */
} COMPCLASS_ID;

typedef enum ccm_msgid
{
  /*	Group: Versioning Messages */
  /*	All of these are global to the .o, and will */
  /*	have lineno = pcoffset = 0 */

CCM_MODDATE=0x00100,   	/* Source file <s1>, last modified on date <s2> */
CCM_COMPVER,           	/* Component <s1>, version <s2> */
			/* [Emitted for each component of the compiler.] */
CCM_COMPDATE,          	/* Compilation date <s1> */
			/* [<s1> is an I18n string with the date and time] */
CCM_COMPOPT,           	/* Compilation options <s1> */
			/* [As specified by the user] */
CCM_ACOMPOPT,          	/* Actual Compilation options <s1> */
			/* [As expanded by the driver] */

  /* Group: Warning Messages */
CCM_VAR_ALIAS=0x00200, 	/* Variable <v1> aliased to <v2> */
CCM_FBIRDIFF,          	/* Profile feedback data inconsistent with */
			/* intermediate representation file; check compiler */
			/* version, flags and source file */
CCM_OPTRED_SWAP,       	/* Optimization level for <p1> reduced from <i2> to */
			/* <i3> due to insufficient swap space */
CCM_OPTRED_CPLX,       	/* Optimization level for <p1> reduced from <i2> to */
			/* <i3> due to program complexity */
CCM_UNKNOWN,           	/* Unexpected compiler comment <i1> */

  /* Group: Parallelization Messages */
CCM_UNPAR_CALL=0x00400,	/* Loop below not parallelized because it contains a */
			/* call to <p1> */

  /* CCMV_WANT: Don't generate CCM_PAR_SER; always use CCM_PAR_SER_VER */
CCM_PAR_SER,           	/* Both serial and parallel versions generated for */
			/* loop below */
CCM_PAR_SER_VER,       	/* Both serial and parallel versions generated for */
			/* loop below; with parallel version used if <s1>, */
			/* serial otherwise */
CCM_PAR_DRECTV,        	/* Loop below parallelized by explicit user */
			/* directive */
CCM_APAR,              	/* Loop below autoparallelized */
CCM_AUTOPAR,           	/* Loop below autoparallelized; equivalent */
			/* explict directive is <s1> */
CCM_UNPAR_DD,          	/* Loop below could not be parallelized because of a */
			/* data dependency on <v1>, <v2>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_UNPAR_DDA,         	/* Loop below could not be parallelized because of a */
			/* data dependency or aliasing of <v1>, <v2>, ... */
CCM_UNPAR_ANONDD,      	/* Loop below could not be parallelized because of */
			/* an anonymous data dependency */
CCM_UNPAR_ANONDDA,     	/* Loop below could not be parallelized because of */
			/* an anonymous data dependency or aliasing */
CCM_PAR_WORK,          	/* Loop below parallelized, but might not contain */
			/* enough work to be efficiently run in parallel */
CCM_UNPAR_EXIT,        	/* Loop below not parallelized because it contains */
			/* multiple exit points */
CCM_UNPAR_STRNG,       	/* Loop below not parallelized because it contains a */
			/* strange flow of control */
CCM_UNPAR_IO,          	/* Loop below not parallelized because it contains */
			/* I/O or other MT-unsafe calls */
CCM_PAR_BODY_NAME,     	/* Parallel loop-body code is in function <p1> */
CCM_UNPAR_NLOOPIDX,    	/* Loop below not parallelized because loop index */
			/* not found */
CCM_UNPAR_DRECTV,      	/* Loop below not parallelized because of explicit */
			/* user directive */
CCM_UNPAR_NOTPROFIT,   	/* Loop below not parallelized because it was not */
			/* profitable to do so */
CCM_UNPAR_NEST,        	/* Loop below not parallelized because it was */
			/* nested in a parallel loop */
CCM_UNPAR,             	/* Loop below not parallelized */
CCM_UNPAR_NOAUTO,      	/* Loop below not parallelized because */
			/* autoparallelization is not enabled */
CCM_PR_L_VAR,          	/* Private variables in loop below: */
			/* <v1>, <v2>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_SH_L_VAR,          	/* Shared variables in loop below: */
			/* <v1>, <v2>, ... */
CCM_TP_L_VAR,          	/* Threadprivate variables in loop below: */
			/* <v1>, <v2>, ... */
CCM_RV_L_VAR,          	/* Reduction variables in loop below: */
			/* <v1>, <v2>, ... */
CCM_IM_L_VAR,          	/* Implicit variables in loop below: */
			/* <v1>, <v2>, ... */
CCM_PR_O_VAR,          	/* Private variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_SH_O_VAR,          	/* Shared variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_TP_O_VAR,          	/* Threadprivate variables in OpenMP construct */
			/* below: <v1>, <v2>, ... */
CCM_RV_O_VAR,          	/* Reduction variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_IM_O_VAR,          	/* Implicit variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_UNPAR_IN_OMP,      	/* Loop below not parallelized because it is inside */
			/* an OpenMP region */
CCM_FP_O_VAR,          	/* Firstprivate variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_LP_O_VAR,          	/* Lastprivate variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_CP_O_VAR,          	/* Copyprivate variables in OpenMP construct below: */
			/* <v1>, <v2>, ... */
CCM_PR_OAS_VAR,        	/* Variables autoscoped as PRIVATE in OpenMP */
			/* construct below: <v1>, <v2>, ... */
CCM_SH_OAS_VAR,        	/* Variables autoscoped as SHARED in OpenMP */
			/* construct below: <v1>, <v2>, ... */
CCM_FP_OAS_VAR,        	/* Variables autoscoped as FIRSTPRIVATE in OpenMP */
			/* construct below: <v1>, <v2>, ... */
CCM_LP_OAS_VAR,        	/* Variables autoscoped as LASTPRIVATE in OpenMP */
			/* construct below: <v1>, <v2>, ... */
CCM_RV_OAS_VAR,        	/* Variables autoscoped as REDUCTION in OpenMP */
			/* construct below: <v1>, <v2>, ... */
CCM_FAIL_OAS_VAR,      	/* Variables cannot be autoscoped in OpenMP */
			/* construct below: <v1>, <v2>, ... */
CCM_SERIALIZE_OAS,     	/* OpenMP parallel region below is serialized */
			/* because autoscoping has failed */
CCM_UNPAR_CALL_2,      	/* <l1> not parallelized because it contains calls */
			/* to: <p2>, <p3>, ... */
CCM_PAR_DRECTV_2,      	/* <l1> parallelized by explicit user directive */
CCM_APAR_2,            	/* <l1> autoparallelized */
CCM_AUTOPAR_2,         	/* <l1> autoparallelized; equivalent */
			/* explict directive is <s2> */
CCM_UNPAR_DD_2,        	/* <l1> could not be parallelized because of */
			/* data dependences on: <v2>, <v3>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_UNPAR_DDA_2,       	/* <l1> could not be parallelized because of a */
			/* data dependence or aliasing of: <v2>, <v3>, ... */
CCM_UNPAR_ANONDD_2,    	/* <l1> could not be parallelized because of an */
			/* anonymous data dependence */
CCM_UNPAR_ANONDDA_2,   	/* <l1> could not be parallelized because of an */
			/* anonymous data dependence or aliasing */
CCM_PAR_WORK_2,        	/* <l1> parallelized, but might not contain */
			/* enough work to run efficiently in parallel */
CCM_UNPAR_EXIT_2,      	/* <l1> not parallelized because it contains */
			/* multiple exit points */
CCM_UNPAR_STRANGE_2,   	/* <l1> not parallelized because it contains a */
			/* strange flow of control */
CCM_UNPAR_IO_2,        	/* <l1> not parallelized because it contains */
			/* I/O or other MT-unsafe calls */
CCM_PAR_BODY_NAME_2,   	/* <l1> parallel loop-body code placed in */
			/* function <p2> along with <i3> inner loops */
CCM_UNPAR_NLOOPIDX_2,  	/* <l1> not parallelized because loop index not */
			/* found */
CCM_UNPAR_DRECTV_2,    	/* <l1> not parallelized because of explicit */
			/* user directive */
CCM_UNPAR_NOTPROFIT_2, 	/* <l1> not parallelized because it was not */
			/* profitable to do so */
CCM_UNPAR_NEST_2,      	/* <l1> not parallelized because it was */
			/* nested within a parallel loop */
CCM_UNPAR_2,           	/* <l1> not parallelized */
CCM_UNPAR_NOAUTO_2,    	/* <l1> not parallelized because */
			/* autoparallelization is not enabled */
CCM_PR_L_VAR_2,        	/* Private variables in <l1>: */
			/* <v2>, <v3>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_SH_L_VAR_2,        	/* Shared variables in <l1>: */
			/* <v2>, <v3>, ... */
CCM_TP_L_VAR_2,        	/* Threadprivate variables in <l1>: */
			/* <v2>, <v3>, ... */
CCM_RV_L_VAR_2,        	/* Reduction variables of operator <s1> in <l2>: */
			/* <v3>, <v4>, ... */
CCM_IM_L_VAR_2,        	/* Implicit variables in <l1>: */
			/* <v2>, <v3>, ... */
CCM_PR_O_VAR_2,        	/* Private variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_SH_O_VAR_2,        	/* Shared variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_TP_O_VAR_2,        	/* Threadprivate variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_RV_O_VAR_2,        	/* Reduction variables of operator <s1> in <r2>: */
			/* <v3>, <v4>, ... */
CCM_IM_O_VAR_2,        	/* Implicit variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_UNPAR_IN_OMP_2,    	/* <l1> not parallelized because it is inside */
			/* OpenMP region <r2> */
CCM_FP_O_VAR_2,        	/* Firstprivate variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_LP_O_VAR_2,        	/* Lastprivate variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_CP_O_VAR_2,        	/* Copyprivate variables in <r1>: */
			/* <v2>, <v3>, ... */
CCM_PR_OAS_VAR_2,      	/* Variables autoscoped as PRIVATE in <r1>: */
			/* <v2>, <v3>, ... */
CCM_SH_OAS_VAR_2,      	/* Variables autoscoped as SHARED in <r1>: */
			/* <v2>, <v3>, ... */
CCM_FP_OAS_VAR_2,      	/* Variables autoscoped as FIRSTPRIVATE in <r1>: */
			/* <v2>, <v3>, ... */
CCM_LP_OAS_VAR_2,      	/* Variables autoscoped as LASTPRIVATE in <r1>: */
			/* <v2>, <v3>, ... */
CCM_RV_OAS_VAR_2,      	/* Variables autoscoped as REDUCTION of operator */
			/* <s1> in <r2>: <v3>, <v4>, ... */
CCM_FAIL_OAS_VAR_2,    	/* Variables treated as shared because they cannot */
			/* be autoscoped in <r1>: <v2>, <v3>, ... */
CCM_SERIALIZE_OAS_2,   	/* <r1> will be executed by a single thread because */
			/* autoscoping for some variables was not successful */

  /* Group: Parallelization Questions asked of the user */
  /*	How will the user answer these questions? */
CCM_QPERMVEC=0x00800,  	/* Is <v1> a permutation vector during execution of */
			/* <l2>? */
CCM_QEXPR,             	/* Is expression <s1> true for <l2>? */
CCM_QSAFECALL,         	/* Is subroutine <p1> MP-safe as used in <l2>? */

  /* Group: Loop Optimization Messages */
CCM_LCOST=0x01000,     	/* Loop below estimated to cost <i1> cycles per */
			/* iteration */
CCM_UNROLL,            	/* Loop below unrolled <i1> times */
  /* CCMV_WANT: the next one should be replaced by CCM_IMIX2 */
CCM_IMIX,              	/* Loop below has <i1> loads, <i2> stores, */
			/* <i3> prefetches, <i4> FPadds, <i5> FPmuls, and */
			/* <i6> FPdivs per iteration */
CCM_SPILLS,            	/* Loop below required <i1> integer register spills, */
			/* <i2> FP register spills, and used */
			/* <i3> integer registers and <i4> FP registers */
CCM_LFISSION,          	/* Loop below fissioned into <i1> loops */
CCM_LPEEL,             	/* Loop below had iterations peeled off for better */
			/* unrolling and/or parallelization */
CCM_LBLOCKED,          	/* Loop below blocked by <i1> for improved cache */
			/* performance */
CCM_LTILED,            	/* Loop below tiled for better performance */
CCM_LUNRJAM,           	/* Loop below unrolled and jammed */
CCM_LWHILE2DO,         	/* Bounds test for loop below moved to top of loop */
CCM_L2CALL,            	/* Loop below replaced by a call to <p1> */
CCM_LDEAD,             	/* Loop below deleted as dead code */
CCM_LINTRCHNG,         	/* Loop below interchanged with loop on line <i1> */
CCM_FUSEDTO,           	/* Loop below fused with loop on line <i1> */
CCM_FUSEDFROM,         	/* Loop from line <i1> fused with loop below */
CCM_VECINTRNSC,        	/* Loop below transformed to use calls to vector */
			/* intrinsic <p1>, <p2>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_LSTRIPMINE,        	/* Loop below strip-mined */
CCM_LNEST2LOOPS,       	/* Loop below collapsed with loop on line <i1> */
CCM_LREVERSE,          	/* Loop below has had its iteration direction */
			/* reversed */
CCM_IMIX2,             	/* Loop below has <i1> loads, <i2> stores, */
			/* <i3> prefetches, <i4> FPadds, <i5> FPmuls, */
			/* <i6> FPdivs, <i7> FPsubs, and <i8> FPsqrts per */
			/* iteration */
CCM_LUNRFULL,          	/* Loop below fully unrolled */
CCM_ELIM_NOAMORTINST,  	/* Loop below was eliminated as it contains no */
			/* non-amortizable instructions */
CCM_COMP_DALIGN,       	/* Performance of loop below could be improved */
			/* by compiling with -dalign */
CCM_INTIMIX,           	/* Loop below has <i1> int-loads, <i2> int-stores, */
			/* <i3> alu-ops, <i4> muls, <i5> int-divs and */
			/* <i6> shifts per iteration */
CCM_LMULTI_VERSION,    	/* <l1> multi-versioned.  Specialized version */
			/* is <l2> */
CCM_LCOST_2,           	/* <l1> estimated to cost <i2> cycles per iteration */
CCM_UNROLL_2,          	/* <l1> unrolled <i2> times */

  /* CCMV_WANT: the next one should be replaced by CCM_IMIX2_B or CCM_IMIX3_B */
CCM_IMIX_B,            	/* <l1> has <i2> loads, <i3> stores, */
			/* <i4> prefetches, <i5> FPadds, <i6> FPmuls, and */
			/* <i7> FPdivs per iteration */
CCM_SPILLS_2,          	/* <l1> required <i2> integer register spills, */
			/* <i3> FP register spills, and used */
			/* <i4> integer registers and <i5> FP registers */
CCM_LFISSION_2,        	/* <l1> fissioned into <i2> loops, generating: */
			/* <l3>, <l4>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_LFISSION_FRAG,     	/* <l1> contains code from lines: <i2>, <i3>, ... */
CCM_LPEEL_2,           	/* <l1> had iterations peeled off for better */
			/* unrolling and/or parallelization */
CCM_LBLOCKED_2,        	/* <l1> blocked by <i2> for improved memory */
			/* hierarchy performance, new inner loop <l3> */
CCM_LOUTER_UNROLL,     	/* <l1> is outer-unrolled <i2> times as part */
			/* of unroll and jam */
CCM_LJAMMED,           	/* All <i1> copies of <l2> are fused together */
			/* as part of unroll and jam */
CCM_LWHILE2DO_2,       	/* Bounds test for <l1> moved to top of loop */
CCM_L2CALL_2,          	/* <l1> replaced by a call to <p2> */
CCM_LDEAD_2,           	/* <l1> deleted as dead code */
CCM_LINTRCHNG_2,       	/* <l1> interchanged with <l2> */
CCM_LINTRCHNG_ORDER,   	/* For loop nest below, the final order of loops */
			/* after interchanging and subsequent */
			/* transformations is: <l1>, <l2>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_FUSED_2,           	/* <l1> fused with <l2>, new loop <l3> */
CCM_VECINTRNSC_2,      	/* <l1> transformed to use calls to vector */
			/* intrinsics: <p2>, <p3>, ... */
CCM_LSTRIPMINE_2,      	/* <l1> strip-mined by <i2>, new inner loop <l3> */
CCM_LNEST2LOOPS_2,     	/* <l1> collapsed with <l2>, new loop <l3> */
CCM_LREVERSE_2,        	/* <l1> has had its iteration direction reversed */
CCM_IMIX2_B,           	/* <l1> has <i2> loads, <i3> stores, */
			/* <i4> prefetches, <i5> FPadds, <i6> FPmuls, */
			/* <i7> FPdivs, <i8> FPsubs, and <i9> FPsqrts per */
			/* iteration */
CCM_LUNRFULL_2,        	/* <l1> fully unrolled */
CCM_ELIM_NOAMORTINST_2,	/* <l1> was eliminated as it contains no */
			/* non-amortizable instructions */
CCM_COMP_DALIGN_2,     	/* Performance of <l1> could be improved by */
			/* compiling with -dalign */
CCM_INTIMIX_2,         	/* <l1> has <i2> int-loads, <i3> int-stores, */
			/* <i4> alu-ops, <i5> muls, <i6> int-divs and */
			/* <i7> shifts per iteration */
CCM_OMP_REGION,        	/* Source OpenMP region below has tag <r1> */
CCM_LMICROVECTORIZE,   	/* <l1> is micro-vectorized */
CCM_LMULTI_VERSION_2,  	/* <l1> multi-versioned for <s2>. */
			/* Specialized version is <l3> */
CCM_LCLONED,           	/* <l1> cloned for <s2>.  Clone is <l3> */
CCM_LUNSWITCHED,       	/* <l1> is unswitched.  New loops */
			/* are <l2> and <l3> */
CCM_LRESWITCHED,       	/* Loops <l1> and <l2> and their surrounding */
			/* conditional code have been merged to */
			/* form loop <l3> */
CCM_LSKEWBLOCKED,      	/* <l1> skew-blocked by <i2> with slope */
			/* <i3> for improved memory hierarchy */
			/* performance, new inner loop <l4> */
CCM_IVSUB,             	/* Induction variable substitution performed on <l1> */
CCM_ONEITER_REPLACED,  	/* <l1> determined to have a trip count of 1; */
			/* converted to straight-line code */
CCM_IMIX3_B,           	/* <l1> has <i2> loads, <i3> stores, */
			/* <i4> prefetches, <i5> FPadds, <i6> FPmuls, */
			/* <i7> FPmuladds, <i8> FPdivs, and <i9> FPsqrts per */
			/* iteration */

  /* Group: Pipelining Messages */
CCM_PIPELINE=0x02000,  	/* Loop below pipelined */
CCM_PIPESTATS,         	/* Loop below scheduled with steady-state cycle */
			/* count = <i1> */
CCM_NOPIPE_CALL,       	/* Loop could not be pipelined because it contains */
			/* calls */
CCM_NOPIPE_INTCC,      	/* Loop could not be pipelined because it sets */
			/* multiple integer condition codes. */
CCM_NOPIPE_MBAR,       	/* Loop could not be pipelined because it contains a */
			/* memory barrier instruction */
CCM_NOPIPE_MNMX,       	/* Loop could not be pipelined because it contains */
			/* a minimum or a maximum operation */
CCM_NOPIPE_U2FLT,      	/* Loop could not be pipelined because it contains */
			/* an unsigned to float conversion */
CCM_NOPIPE_GOT,        	/* Loop could not be pipelined because it sets the */
			/* Global Offset Table pointer */
CCM_NOPIPE_IDIV,       	/* Loop could not be pipelined because it contains */
			/* an integer divide */
CCM_NOPIPE_PRFTCH,     	/* Loop could not be pipelined because it contains */
			/* a prefetch operation */
CCM_NOPIPE_EXIT,       	/* Loop could not be pipelined because it contains */
			/* an exit operation */
CCM_NOPIPE_REG,        	/* Loop could not be pipelined because it contains */
			/* instructions that set the %gsr or %fsr register */
CCM_NOPIPE_UNS,        	/* Loop could not be pipelined because it has an */
			/* unsigned loop counter */
CCM_NOPIPE_UNSUIT,     	/* Loop was unsuitable for pipelining */
CCM_NOPIPE_INTRINSIC,  	/* Loop could not be pipelined because it has an */
			/* intrinsic call to <p1> */
CCM_NOPIPE_BIG,        	/* Loop could not be pipelined as it is too big */
CCM_NOPIPE_INVINTPR,   	/* Loop could not be pipelined as it contains too */
			/* many loop invariant integers = <i1> */
CCM_NOPIPE_INVFLTPR,   	/* Loop could not be pipelined as it contains too */
			/* many loop invariant floats = <i1> */
CCM_NOPIPE_INVDBLPR,   	/* Loop could not be pipelined as it contains too */
			/* many loop invariant doubles = <i1> */
CCM_PIPE_SCHEDAFIPR,   	/* Loop below was adversely affected by high */
			/* integer register pressure = <i1> */
CCM_PIPE_SCHEDAFDPR,   	/* Loop below was adversely affected by high */
			/* double register pressure = <i1> */
CCM_PIPE_SCHEDAFFPR,   	/* Loop below was adversely affected by high */
			/* float register pressure = <i1> */
CCM_NOPIPE_INTPR,      	/* Loop could not be pipelined due to high */
			/* integer register pressure = <i1> */
CCM_NOPIPE_DBLPR,      	/* Loop could not be pipelined due to high */
			/* double register pressure = <i1> */
CCM_NOPIPE_FLTPR,      	/* Loop could not be pipelined due to high */
			/* float register pressure = <i1> */
CCM_PIPELINE_2,        	/* <l1> pipelined */
CCM_PIPESTATS_2,       	/* <l1> scheduled with steady-state cycle */
			/* count = <i2> */
CCM_NOPIPE_CALL_2,     	/* <l1> could not be pipelined because it contains */
			/* calls */
CCM_NOPIPE_INTCC_2,    	/* <l1> could not be pipelined because it sets */
			/* multiple integer condition codes. */
CCM_NOPIPE_MBAR_2,     	/* <l1> could not be pipelined because it contains */
			/* a memory barrier instruction */
CCM_NOPIPE_MNMX_2,     	/* <l1> could not be pipelined because it contains */
			/* a minimum or a maximum operation */
CCM_NOPIPE_U2FLT_2,    	/* <l1> could not be pipelined because it contains */
			/* an unsigned to float conversion */
CCM_NOPIPE_GOT_2,      	/* <l1> could not be pipelined because it sets the */
			/* Global Offset Table pointer */
CCM_NOPIPE_IDIV_2,     	/* <l1> could not be pipelined because it contains */
			/* an integer divide */
CCM_NOPIPE_PRFTCH_2,   	/* <l1> could not be pipelined because it contains */
			/* a prefetch operation */
CCM_NOPIPE_EXIT_2,     	/* <l1> could not be pipelined because it contains */
			/* an exit operation */
CCM_NOPIPE_REG_2,      	/* <l1> could not be pipelined because it contains */
			/* instructions that set the %gsr or %fsr register */
CCM_NOPIPE_UNS_2,      	/* <l1> could not be pipelined because it has an */
			/* unsigned loop counter */
CCM_NOPIPE_UNSUIT_2,   	/* <l1> is unsuitable for pipelining */
CCM_NOPIPE_INTRINSIC_2,	/* <l1> could not be pipelined because it contains */
			/* a call to intrinsic <p2> */
CCM_NOPIPE_BIG_2,      	/* <l1> could not be pipelined as it is too big */
CCM_NOPIPE_INVINTPR_2, 	/* <l1> could not be pipelined as it contains too */
			/* many loop invariant integers = <i2> */
CCM_NOPIPE_INVFLTPR_2, 	/* <l1> could not be pipelined as it contains too */
			/* many loop invariant floats = <i2> */
CCM_NOPIPE_INVDBLPR_2, 	/* <l1> could not be pipelined as it contains too */
			/* many loop invariant doubles = <i2> */
CCM_PIPE_SCHEDAFIPR_2, 	/* <l1> was adversely affected by high */
			/* integer register pressure = <i2> */
CCM_PIPE_SCHEDAFDPR_2, 	/* <l1> was adversely affected by high */
			/* double register pressure = <i2> */
CCM_PIPE_SCHEDAFFPR_2, 	/* <l1> was adversely affected by high */
			/* float register pressure = <i2> */
CCM_NOPIPE_INTPR_2,    	/* <l1> could not be pipelined due to high */
			/* integer register pressure = <i2> */
CCM_NOPIPE_DBLPR_2,    	/* <l1> could not be pipelined due to high */
			/* double register pressure = <i2> */
CCM_NOPIPE_FLTPR_2,    	/* <l1> could not be pipelined due to high */
			/* float register pressure = <i2> */

  /* Group: Inlining Messages */
CCM_INLINE=0x04000,    	/* Function <p1> inlined from source file <s2> into */
			/* the code for the following line */
CCM_INLINE2,           	/* Function <p1> inlined from source file <s2> into */
			/* inline copy of function <p3> */
CCM_INLINE_TMPLT,      	/* Function <p1> inlined from template file <s2> */
			/* into the code for the following line */
CCM_INLINE_TMPLT2,     	/* Function <p1> inlined from template file <s2> */
			/* into inline copy of function <p3> */
CCM_INLINE_OUT_COPY,   	/* Out-of-line copy of inlined function <p1> from */
			/* source file <s2> generated */
CCM_NINLINE_REC,       	/* Recursive function <p1> inlined only up to */
			/* depth <i2> */
CCM_NINLINE_NEST,      	/* Function <p1> not inlined because inlining is */
			/* already nested too deeply */
CCM_NINLINE_CMPLX,     	/* Function <p1> not inlined because it contains */
			/* too many operations */
CCM_NINLINE_FB,        	/* Function <p1> not inlined because the */
			/* profile-feedback execution count is too low */
CCM_NINLINE_PAR,       	/* Function <p1> not inlined because it contains */
			/* explicit parallel pragmas */
CCM_NINLINE_OPT,       	/* Function <p1> not inlined because it is */
			/* compiled with optimization level <= 2 */
CCM_NINLINE_USR,       	/* Function <p1> not inlined because either command */
			/* line option or source code pragma prohibited it, */
			/* or it's not safe to inline it */
CCM_NINLINE_AUTO,      	/* Function <p1> not inlined because doing so */
			/* would make automatic storage for <p2> too large */
CCM_NINLINE_CALLS,     	/* Function <p1> not inlined because it contains */
			/* too many calls */
CCM_NINLINE_ACTUAL,    	/* Function <p1> not inlined because it has more */
			/* actual parameters than formal parameters */
CCM_NINLINE_FORMAL,    	/* Function <p1> not inlined because it has more */
			/* formal parameters than actual parameters */
CCM_NINLINE_TYPE,      	/* Function <p1> not inlined because formal */
			/* argument type does not match actual type */
CCM_NINLINE_ATYPE,     	/* Function <p1> not inlined because array formal */
			/* argument does not match reshaped array actual */
			/* argument type */
CCM_NINLINE_RETTYPE,   	/* Function <p1> not inlined because return type */
			/* does not match */
CCM_NINLINE_EXCPT,     	/* Function <p1> not inlined because it */
			/* guarded by an exception handler */
CCM_NINLINE_UNSAFE,    	/* Function <p1> not inlined because it might be */
			/* unsafe (call alloca(), etc) */
CCM_NINLINE_ALIAS,     	/* Function <p1> not inlined because inlining it */
			/* will make the alias analysis in the calling */
			/* function more conservative */
CCM_NINLINE_FEMARK,    	/* Function <p1> not inlined because it contains */
			/* setjmp/longjmp, or indirect goto, etc */
CCM_NINLINE_RAREX,     	/* Function <p1> not inlined because it is known */
			/* to be rarely executed */
CCM_CLONING,           	/* Function <p1> from source file <s2> cloned, */
			/* creating cloned function <p3>; constant */
			/* parameters propagated to clone */
CCM_INLINE_B,          	/* Function <p1> inlined from source file <s2> into */
			/* the code for the following line.  <i3> loops */
			/* inlined */
CCM_INLINE2_B,         	/* Function <p1> inlined from source file <s2> into */
			/* inline copy of function <p3>.  <i4> loops inlined */
CCM_INLINE_LOOP,       	/* Loop in function <p1>, line <i2> has */
			/* tag <l3> */
CCM_NINLINE_MULTIENTRY,	/* Function <p1> not inlined because it */
			/* contains an ENTRY statement */
CCM_NINLINE_VARARGS,   	/* Function <p1> not inlined because variable */
			/* argument routines cannot be inlined */
CCM_NINLINE_UNSEEN_BODY,	/* Function <p1> not inlined because the compiler */
			/* has not seen the body of the function.  Use */
			/* -xcrossfile or -xipo in order to inline it */
CCM_NINLINE_UPLEVEL,   	/* Function <p1> not inlined because it is a */
			/* nested routine containing references to */
			/* variables defined in an outer function */
CCM_NINLINE_CMDLINE,   	/* Function <p1> not inlined because either */
			/* -xinline or source code pragma prohibited it */
CCM_NINLINE_CALL_CMPLX,	/* Call to <p1> not inlined because of the */
			/* complexity of the calling routine */
CCM_NINLINE_LANG_MISMATCH,	/* Call to <p1> not inlined because it is in */
			/* a different language */
CCM_NINLINE_RTN_WEAK,  	/* Function <p1> not inlined because it */
			/* is marked weak */
CCM_NINLINE_CALL_WEAKFILE,	/* Call to <p1> not inlined because it is */
			/* in a different file and it contains a */
			/* call to a weak routine */
CCM_NINLINE_CALL_TRYCATCH,	/* Call to <p1> not inlined because it is */
			/* in a different file and contains an */
			/* explicit try/catch */
CCM_NINLINE_CALL_REGP, 	/* Call to <p1> not inlined because it would */
			/* cause excessive register pressure */
CCM_NINLINE_RTN_REGP,  	/* Function <p1> not inlined because it would */
			/* cause excessive register pressure */
CCM_NINLINE_CALL_XPENSV,	/* Call to <p1> not inlined because analysis */
			/* exceeds the compilation time limit */
CCM_NINLINE_READONLYIR,	/* Function <p1> not inlined because it is in a file */
			/* specified as read-only by -xipo_archive=readonly */
			/* and it contains calls to static functions */
CCM_NINLINE_CALL_THUNK,	/* Call to <p1> not inlined because it is in a */
			/* compiler-generated function that does not */
			/* permit inlining */
CCM_NINLINE_CALL_XTARGETS,	/* Indirect callsite has too many targets; */
			/* callsite marked do not inline */
CCM_NINLINE_SELFTAIL_RECURSIVE,	/* Function <p1> not inlined because */
			/* of a recursive tail-call to itself */
CCM_NINLINE_PRAGMA,    	/* Function <p1> not inlined because it contains */
			/* explicit parallel or alias pragmas */
CCM_NINLINE_CMPLX2,    	/* Function <p1> not inlined because it contains too */
			/* many operations.  Increase max_inst_hard in order */
			/* to inline it: -xinline_param=max_inst_hard:n */
CCM_NINLINE_RARE,      	/* Function <p1> not inlined because the call */
			/* is rarely executed */
CCM_NINLINE_PAR2,      	/* Function <p1> not inlined because it is called */
			/* within a region guarded by an explicit */
			/* parallel pragmas */
CCM_NINLINE_G_LIMIT,   	/* Function <p1> not inlined because it would exceed */
			/* the permitted global code size growth limit.  Try */
			/* to increase max_growth in order to inline it: */
			/* -xinline_param=max_growth:n */
CCM_NINLINE_L_LIMIT,   	/* Function <p1> not inlined because it would exceed */
			/* the maximum function size growth limit.  Increase */
			/* max_function_inst in order to inline it: */
			/* -xinline_param=max_function_inst:n */
CCM_NINLINE_REC2,      	/* Recursive function <p1> is inlined only up to */
			/* <i2> levels and up to <i3> size.  Increase */
			/* max_recursive_deptha or max_recursive_inst in */
			/* order to inline it: */
			/* -xinline_param=max_recursive_depth:n, */
			/* -xinline_param=max_recursive_inst:n */
CCM_NINLINE_FB2,       	/* Function <p1> not inlined because the */
			/* profile-feedback execution count is too */
			/* low.  Decrease min_counter in order to inline it: */
			/* -xinline_param:min_counter:n */
CCM_NINLINE_CS_CMPLX,  	/* Function <p1> not inlined because called */
			/* function's size is too big.  Increase */
			/* max_inst_soft in order to inline it: */
			/* -xinline_param=max_inst_soft:n */
CCM_NINLINE_R_EXCPT,   	/* Function <p1> not inlined because it contains */
			/* an exception handler */
CCM_NINLINE_ASM,       	/* Function <p1> not inlined because */
			/* it contains asm statements */
CCM_NINLINE_R_READONLYIR,	/* Function <p1> not inlined because it is in a file */
			/* specified as read-only by -xipo_archive=readonly */
			/* and it is a static function */
CCM_NINLINE_C_READONLYIR,	/* Call to <p1> not inlined because the calling */
			/* function is in a file specified as read-only */
			/* by -xipo_archive=readonly */
CCM_NINLINE_NEVERRETURN,	/* Function <p1> not inlined because it */
			/* never returns */

  /* Group: Messages Concerning Memory Operations */
  /*	Notes: */
  /*	a.  In all of these, <s1> is a string that is something like */
  /*	"A(i+5*k)" or "structure.field", giving the high-level */
  /*	construct that is being loaded or stored. */
  /*	 */
  /*	b.  In all of these, <x2> refers to an instruction offset, */
  /*	expressed as a 32-bit signed integer.  It is assumed */
  /*	that any prefetches will be within this range of the */
  /*	load/store they are prefetching for. */
CCM_MPREFETCH=0x08000, 	/* Prefetch of <s1> inserted */
			/* [This message has a lineno for the source, */
			/* but no instaddr for the disassembly.] */
CCM_MPREFETCH_LD,      	/* Prefetch of <s1> inserted for load at <x2> */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MPREFETCH_ST,      	/* Prefetch of <s1> inserted for store at <x2> */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MPREFETCH_FB,      	/* Prefetch of <s1> inserted based on feedback data */
			/* [This message has a lineno for the source, */
			/* but no instaddr for the disassembly.] */
CCM_MPREFETCH_FB_LD,   	/* Prefetch of <s1> inserted for load at <x2> based */
			/* on feedback data */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MPREFETCH_FB_ST,   	/* Prefetch of <s1> inserted for store at <x2> based */
			/* on feedback data */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MLOAD,             	/* Load below refers to <s1> */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MSTORE,            	/* Store below refers to <s1> */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MLOAD_P,           	/* Load below refers to <s1>, and was prefetched */
			/* at <x2> */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */
CCM_MSTORE_P,          	/* Store below refers to <s1>, and was prefetched */
			/* at <x2> */
			/* [This message has lineno = -1, */
			/* and is for disassembly only] */

  /* Group: Front-end messages [all compilers] */
  /* Group: F95 Front-end Messages */
CCM_COPYIN=0x10000,    	/* Parameter <i1> caused a copyin in the following */
			/* call */
CCM_COPYOUT,           	/* Parameter <i1> caused a copyout in the following */
			/* call */
CCM_COPYINOUT,         	/* Parameter <i1> caused both a copyin and copyout */
			/* in the following call */
CCM_PADDING,           	/* Padding of <i1> bytes inserted before */
			/* array <v2> */
CCM_PADCOMMON,         	/* Padding of <i1> bytes inserted before */
			/* array <v2> in common block <v3> */
CCM_ALIGN_EQ,          	/* Variable/array <v1> can not be double-aligned, */
			/* because it is equivalenced */
CCM_ALIGN_PERF,        	/* Alignment of variables in common block may cause */
			/* performance degradation */
CCM_ALIGN_STRUCT,      	/* Alignment of component <s1> in numeric sequence */
			/* structure <s2> may cause performance degradation */
CCM_TMP_COPY,          	/* Argument <v1> copied to a temporary */
CCM_TMP_COPYM,         	/* Argument <v1> might be copied to a temporary; */
			/* runtime decision made */
CCM_PROC_MISMATCH,     	/* Argument <i1> to subprogram <p2> differs from */
			/* reference on line <i3> */
CCM_PROC_MISMATCH2,    	/* Scalar argument <i1> to subprogram <p2> is */
			/* referred to as an array on line <i3> */
CCM_PROC_MISMATCH3,    	/* Return type/rank from subprogram <p1> differs */
			/* from return on line <i2> */
CCM_DO_EXPR,           	/* DO statement bounds lead to no executions of the */
			/* loop */
CCM_AUTO_BND,          	/* The bounds for automatic variable <v1> are not */
			/* available at all entry points; zero-length */
			/* variable might be allocated */
CCM_LIT_PAD,           	/* The character string literal <s1> padded */
			/* to the length specified for the dummy argument */
CCM_ARRAY_LOOP,        	/* Array statement below generated a loop */
CCM_ARRAY_LOOPNEST,    	/* Array statement below generated <i1> nested loops */
CCM_ALIGN_PERF2,       	/* Alignment of variable <v1> in common block <v2> */
			/* may cause a performance degradation */
CCM_ALIGN_PERF3,       	/* Alignment of variable <v1> in blank common may */
			/* cause a performance degradation */
CCM_IO_LOOP_ARRAY,     	/* I/O implied do item below generated an array */
			/* section */

  /* Group: C++ Front-end Messages */
CCM_TMPCONST,          	/* Implicit invocation of class <s1> constructor for */
			/* temporary */
CCM_TMPDEST,           	/* Implicit invocation of class <s1> destructor for */
			/* temporary */
CCM_DBL_CONST,         	/* Double constant <s1> used in float expression */
CCM_MINLINE,           	/* Function <p1> inlined from source file <s2> by */
			/* front-end */
			/* [This refers to front-end inlining, */
			/* not the backend inlining above.] */
CCM_MINLINE2,          	/* Function <p1> from source file <s2> inlined into */
			/* inline copy of method <p3> by front-end */
			/* [This refers to front-end inlining, */
			/* not the backend inlining above.] */
CCM_MINLINE3,          	/* Function <p1> not inlined because it uses keyword */
			/* <s2> */
CCM_MINLINE4,          	/* Function <p1> not inlined because it is too */
			/* complex */
CCM_TMP_COPYOUT,       	/* Argument <v1> copied from a temporary */
CCM_TMP_COPYOUTM,      	/* Argument <v1> might be copied from a temporary; */
			/* runtime decision made */
CCM_TMP_COPYINOUT,     	/* Argument <v1> copied in and out of a temporary */
CCM_TMP_COPYINOUTM,    	/* Argument <v1> might be copied in and out of */
			/* a temporary; runtime decision made */

  /* Group: C Front-end Messages */
  /* Group: NJC Front-end Messages */
  /* Group: Updated F95 Front-end Messages */
CCM_ARRAY_LOOP_2,      	/* Array statement below generated loop <l1> */
CCM_ARRAY_LOOPNEST_2,  	/* Array statement below generated <i1> nested */
			/* loops: <l2>, <l3>, ... */
			/* [The number of parameters will determine how many */
			/* names appear, and the formatter will get the */
			/* commas right.] */
CCM_IO_LOOP_ARRAY_2,   	/* I/O implied do item below generated an array */
			/* section: <l1> */
CCM_USER_LOOP,         	/* Source loop below has tag <l1> */
CCM_FOUND_LOOP,        	/* Discovered loop below has tag <l1> */
CCM_MFUNCTION_LOOP,    	/* Copy in M-function of loop below has tag <l1> */

  /* Group: Code-generator Messages */
CCM_FSIMPLE=0x20000,   	/* Transformations for fsimple=<i1> applied */
CCM_STACK,             	/* Function <p1> requires <i2> Mbytes of stack */
			/* storage */
CCM_TAILRECUR,         	/* Recursive tail call in <p1> optimized to jump to */
			/* entry point */
CCM_TAILCALL,          	/* Call to function <p1> was tail-call optimized */
CCM_NI_EXIT_OR_PSEUDO, 	/* Template could not be early inlined because it */
			/* contains the pseudo instruction <s1> */
CCM_NI_BAD_UNARY_OPC,  	/* Template could not be early inlined because it */
			/* contains the instruction opcode <s1> */
CCM_NI_INT_LDD_ON_V9,  	/* Template could not be early inlined because it */
			/* contains integer ldd instructions, which are */
			/* deprecated in the v9 architecture */
CCM_NI_LATE_INL_OPC,   	/* Template could not be early inlined because it */
			/* contains the instruction opcode <s1> */
CCM_NI_BAD_IMM_OP,     	/* Template could not be early inlined because the */
			/* relocation or immediate operand <s1> is not well */
			/* understood by the optimizer */
CCM_NI_BAD_STATELEAF,  	/* Template could not be early inlined because it */
			/* references the state register <s1> */
CCM_NI_BAD_ASR_19,     	/* Template could not be early inlined because */
			/* %asr19 is not supported in pre v8plus code */
CCM_NI_BAD_FSR_USE,    	/* Template could not be early inlined because */
			/* references to %fsr can only be optimized when the */
			/* -iaopts flag is used */
CCM_NI_BAD_REGISTER,   	/* Template could not be early inlined because it */
			/* references the register <s1> */
CCM_NI_NO_RET_VAL,     	/* Template could not be early inlined because it */
			/* does not return the value declared */
CCM_NI_DELAY,          	/* Template could not be early inlined because it */
			/* contains a non nop delay slot */
CCM_NI_SCALL,          	/* Template could not be early inlined because it */
			/* calls a function which returns a structure */
CCM_CASE_POSITION,     	/* Case block below was placed at position <i1> */
			/* based on execution frequency */
CCM_CALL_WITH_CODE,    	/* Call to <p1> replaced with inline code.  <i2> */
			/* loops created: <l3>, <l4>, ... */
CCM_NI_BAD_SP_ADDR,    	/* Template could not be early inlined because it */
			/* contains a %sp+reg address */
CCM_NI_BAD_SP_USAGE,   	/* Template could not be early inlined because it */
			/* uses/defines the stack pointer in a non-load/store instruction */
CCM_NI_MIXED_REG_TYPES,	/* Template could not be early inlined because it */
			/* contains register <s1> used as both x-register and register pair */
CCM_LAST
} COMPMSG_ID;
/*
 * The Message Structure
 * Each message is a fixed-length structure as follows:
 */
typedef struct
{
  int64_t instaddr;     /* the PC offset, relative to the .o .text section */
  int32_t lineno;       /* the source line to which it refers */
  COMPMSG_ID msg_type;  /* the specific message index */
  int32_t nparam;       /* number of parameters to this message */
  int32_t param_index;  /* the index of the first parameter */
} compmsg;

#if defined(__cplusplus)
extern "C"
{
#endif
  /*
   * Initializes the data structures, converts the source name to a string,
   * and fills in srcname and version in the header
   */
  void compcom_p_open (char *srcname, int32_t version);

  /*
   * Finds or enters the string s into the string table, and returns the index
   * of the string
   */
  int32_t compcom_p_string (char *s);

  /*
   * Enter the single message.  Any string parameters should have been converted
   * to int32's by calling compcom_p_string()
   */
  void compcom_p_putmsg (int32_t show_bits, int64_t pcoffset, int32_t lineno,
			 COMPMSG_ID m, int32_t nparams);

  /*
   * Whatever is needed to close the section and write it out to the .o
   */
  void compcom_p_finalize ();

#if defined(__cplusplus)
}
#endif

#endif /* _COMP_COM_H */