gprofng/src/comp_com.h

   1 /* Copyright (C) 2021 Free Software Foundation, Inc.
   2    Contributed by Oracle.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program 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 3, or (at your option)
   9    any later version.
  10
  11    This program 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 this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #ifndef _COMP_COM_H
  22 #define _COMP_COM_H
  23
  24 #include <sys/types.h>
  25 #include <nl_types.h>
  26
  27 /*
  28  * This file describes format for the compiler-commentary
  29  * section to be added to .o's and propagated to the a.out.  It reflects
  30  * information the compiler can expose to the user about his or her
  31  * program.  The section should be generated for all compiles where
  32  * the user has specified -g on the compile line.
  33  *
  34  * In the analyzer, display of the messages will be governed by a user UI
  35  * that sets a vis_bits bitmap, and matches it against a show_bits
  36  * bitmap table, which is maintained separately from the producer
  37  * code.  For any message, if (vis_bits&show_bits) is  non-zero, the
  38  * message is shown.  If zero, the message is not shown.  A similar
  39  * mechanism would be used for a stand-alone source or disassembly browser.
  40  *
  41  *
  42  * The .compcom Section
  43  * --------------------
  44  * The section will be named ".compcom"; it is generated for each
  45  * .o, and aggregated into a single section in the a.out.  In that
  46  * section, each .o's data is separate, and the tools will loop
  47  * over the data for each .o in order to find the subsection for
  48  * the particular .o being annotated.
  49  *
  50  *
  51  * Since the header is fixed-length, and the total size of the section
  52  * can be easily determined as:
  53  *
  54  *     sizeof(stuct compcomhdr)
  55  *      + msgcount * sizeof(struct compmsg)
  56  *      + paramcount * sizeof(int32_t)
  57  *      + stringlen
  58  *
  59  * there is no need to have the size in the header.
  60  */
  61
  62 typedef struct
  63 { /* Header describing the section */
  64   int32_t srcname;          /* index into strings of source file path */
  65   int32_t version;          /* a version number for the .compcom format */
  66   int32_t msgcount;         /* count of messages in the section */
  67   int32_t paramcount;       /* count of parameters in the section */
  68   int32_t stringcount;      /* count of strings in the section */
  69   int32_t stringlen;        /* count of total bytes in strings */
  70 } compcomhdr;
  71
  72 /*
  73  * The data for the .o after the header as:
  74  *
  75  *    compmsg   msgs[msgcount];         the array of messages
  76  *    int32_t   param[paramcount];      the parameters used in the messages
  77  *                                      parameters are either integers or
  78  *                                      string-indices
  79  *    char      msgstrings[stringlen];  the strings used in the messages
  80  */
  81
  82 /*
  83  * Message Classes and Visualization Bits
  84  * --------------------------------------
  85  * Each of the messages above may belong to zero or more visualization
  86  * classes, governed by a table using zero or more of the following symbolic
  87  * names for the classes:
  88  */
  89 typedef enum {
  90 CCMV_WANT   = 0x000,            /* High-priority RFE -- used only for human */
  91                                 /*   reading of message list */
  92 CCMV_UNIMPL = 0x000,            /* Unimplemented -- used only for human */
  93                                 /*   reading of message list */
  94 CCMV_OBS    = 0x000,            /* Obsolete -- to be replaced by a different */
  95                                 /*   message with different parameters -- */
  96                                 /*   used only for human reading of message */
  97                                 /*   list */
  98 CCMV_VER    = 0x001,            /* Versioning messages */
  99 CCMV_WARN   = 0x002,            /* Warning messages */
 100 CCMV_PAR    = 0x004,            /* Parallelization messages */
 101 CCMV_QUERY  = 0x008,            /* Compiler queries */
 102 CCMV_LOOP   = 0x010,            /* Loop detail messages */
 103 CCMV_PIPE   = 0x020,            /* Pipelining messages */
 104 CCMV_INLINE = 0x040,            /* Inlining information */
 105 CCMV_MEMOPS = 0x080,            /* Messages concerning memory operations */
 106 CCMV_FE     = 0x100,            /* Front-end messages (all compilers) */
 107 CCMV_CG     = 0x200,            /* Code-generator messages (all compilers) */
 108 CCMV_BASIC  = 0x400,            /* for default messages */
 109 CCMV_ALL    = 0x7FFFFFFF        /* for all messages */
 110 } COMPCLASS_ID;
 111
 112 typedef enum ccm_msgid
 113 {
 114   /*    Group: Versioning Messages */
 115   /*    All of these are global to the .o, and will */
 116   /*    have lineno = pcoffset = 0 */
 117
 118 CCM_MODDATE=0x00100,    /* Source file <s1>, last modified on date <s2> */
 119 CCM_COMPVER,            /* Component <s1>, version <s2> */
 120                         /* [Emitted for each component of the compiler.] */
 121 CCM_COMPDATE,           /* Compilation date <s1> */
 122                         /* [<s1> is an I18n string with the date and time] */
 123 CCM_COMPOPT,            /* Compilation options <s1> */
 124                         /* [As specified by the user] */
 125 CCM_ACOMPOPT,           /* Actual Compilation options <s1> */
 126                         /* [As expanded by the driver] */
 127
 128   /* Group: Warning Messages */
 129 CCM_VAR_ALIAS=0x00200,  /* Variable <v1> aliased to <v2> */
 130 CCM_FBIRDIFF,           /* Profile feedback data inconsistent with */
 131                         /* intermediate representation file; check compiler */
 132                         /* version, flags and source file */
 133 CCM_OPTRED_SWAP,        /* Optimization level for <p1> reduced from <i2> to */
 134                         /* <i3> due to insufficient swap space */
 135 CCM_OPTRED_CPLX,        /* Optimization level for <p1> reduced from <i2> to */
 136                         /* <i3> due to program complexity */
 137 CCM_UNKNOWN,            /* Unexpected compiler comment <i1> */
 138
 139   /* Group: Parallelization Messages */
 140 CCM_UNPAR_CALL=0x00400, /* Loop below not parallelized because it contains a */
 141                         /* call to <p1> */
 142
 143   /* CCMV_WANT: Don't generate CCM_PAR_SER; always use CCM_PAR_SER_VER */
 144 CCM_PAR_SER,            /* Both serial and parallel versions generated for */
 145                         /* loop below */
 146 CCM_PAR_SER_VER,        /* Both serial and parallel versions generated for */
 147                         /* loop below; with parallel version used if <s1>, */
 148                         /* serial otherwise */
 149 CCM_PAR_DRECTV,         /* Loop below parallelized by explicit user */
 150                         /* directive */
 151 CCM_APAR,               /* Loop below autoparallelized */
 152 CCM_AUTOPAR,            /* Loop below autoparallelized; equivalent */
 153                         /* explict directive is <s1> */
 154 CCM_UNPAR_DD,           /* Loop below could not be parallelized because of a */
 155                         /* data dependency on <v1>, <v2>, ... */
 156                         /* [The number of parameters will determine how many */
 157                         /* names appear, and the formatter will get the */
 158                         /* commas right.] */
 159 CCM_UNPAR_DDA,          /* Loop below could not be parallelized because of a */
 160                         /* data dependency or aliasing of <v1>, <v2>, ... */
 161 CCM_UNPAR_ANONDD,       /* Loop below could not be parallelized because of */
 162                         /* an anonymous data dependency */
 163 CCM_UNPAR_ANONDDA,      /* Loop below could not be parallelized because of */
 164                         /* an anonymous data dependency or aliasing */
 165 CCM_PAR_WORK,           /* Loop below parallelized, but might not contain */
 166                         /* enough work to be efficiently run in parallel */
 167 CCM_UNPAR_EXIT,         /* Loop below not parallelized because it contains */
 168                         /* multiple exit points */
 169 CCM_UNPAR_STRNG,        /* Loop below not parallelized because it contains a */
 170                         /* strange flow of control */
 171 CCM_UNPAR_IO,           /* Loop below not parallelized because it contains */
 172                         /* I/O or other MT-unsafe calls */
 173 CCM_PAR_BODY_NAME,      /* Parallel loop-body code is in function <p1> */
 174 CCM_UNPAR_NLOOPIDX,     /* Loop below not parallelized because loop index */
 175                         /* not found */
 176 CCM_UNPAR_DRECTV,       /* Loop below not parallelized because of explicit */
 177                         /* user directive */
 178 CCM_UNPAR_NOTPROFIT,    /* Loop below not parallelized because it was not */
 179                         /* profitable to do so */
 180 CCM_UNPAR_NEST,         /* Loop below not parallelized because it was */
 181                         /* nested in a parallel loop */
 182 CCM_UNPAR,              /* Loop below not parallelized */
 183 CCM_UNPAR_NOAUTO,       /* Loop below not parallelized because */
 184                         /* autoparallelization is not enabled */
 185 CCM_PR_L_VAR,           /* Private variables in loop below: */
 186                         /* <v1>, <v2>, ... */
 187                         /* [The number of parameters will determine how many */
 188                         /* names appear, and the formatter will get the */
 189                         /* commas right.] */
 190 CCM_SH_L_VAR,           /* Shared variables in loop below: */
 191                         /* <v1>, <v2>, ... */
 192 CCM_TP_L_VAR,           /* Threadprivate variables in loop below: */
 193                         /* <v1>, <v2>, ... */
 194 CCM_RV_L_VAR,           /* Reduction variables in loop below: */
 195                         /* <v1>, <v2>, ... */
 196 CCM_IM_L_VAR,           /* Implicit variables in loop below: */
 197                         /* <v1>, <v2>, ... */
 198 CCM_PR_O_VAR,           /* Private variables in OpenMP construct below: */
 199                         /* <v1>, <v2>, ... */
 200 CCM_SH_O_VAR,           /* Shared variables in OpenMP construct below: */
 201                         /* <v1>, <v2>, ... */
 202 CCM_TP_O_VAR,           /* Threadprivate variables in OpenMP construct */
 203                         /* below: <v1>, <v2>, ... */
 204 CCM_RV_O_VAR,           /* Reduction variables in OpenMP construct below: */
 205                         /* <v1>, <v2>, ... */
 206 CCM_IM_O_VAR,           /* Implicit variables in OpenMP construct below: */
 207                         /* <v1>, <v2>, ... */
 208 CCM_UNPAR_IN_OMP,       /* Loop below not parallelized because it is inside */
 209                         /* an OpenMP region */
 210 CCM_FP_O_VAR,           /* Firstprivate variables in OpenMP construct below: */
 211                         /* <v1>, <v2>, ... */
 212 CCM_LP_O_VAR,           /* Lastprivate variables in OpenMP construct below: */
 213                         /* <v1>, <v2>, ... */
 214 CCM_CP_O_VAR,           /* Copyprivate variables in OpenMP construct below: */
 215                         /* <v1>, <v2>, ... */
 216 CCM_PR_OAS_VAR,         /* Variables autoscoped as PRIVATE in OpenMP */
 217                         /* construct below: <v1>, <v2>, ... */
 218 CCM_SH_OAS_VAR,         /* Variables autoscoped as SHARED in OpenMP */
 219                         /* construct below: <v1>, <v2>, ... */
 220 CCM_FP_OAS_VAR,         /* Variables autoscoped as FIRSTPRIVATE in OpenMP */
 221                         /* construct below: <v1>, <v2>, ... */
 222 CCM_LP_OAS_VAR,         /* Variables autoscoped as LASTPRIVATE in OpenMP */
 223                         /* construct below: <v1>, <v2>, ... */
 224 CCM_RV_OAS_VAR,         /* Variables autoscoped as REDUCTION in OpenMP */
 225                         /* construct below: <v1>, <v2>, ... */
 226 CCM_FAIL_OAS_VAR,       /* Variables cannot be autoscoped in OpenMP */
 227                         /* construct below: <v1>, <v2>, ... */
 228 CCM_SERIALIZE_OAS,      /* OpenMP parallel region below is serialized */
 229                         /* because autoscoping has failed */
 230 CCM_UNPAR_CALL_2,       /* <l1> not parallelized because it contains calls */
 231                         /* to: <p2>, <p3>, ... */
 232 CCM_PAR_DRECTV_2,       /* <l1> parallelized by explicit user directive */
 233 CCM_APAR_2,             /* <l1> autoparallelized */
 234 CCM_AUTOPAR_2,          /* <l1> autoparallelized; equivalent */
 235                         /* explict directive is <s2> */
 236 CCM_UNPAR_DD_2,         /* <l1> could not be parallelized because of */
 237                         /* data dependences on: <v2>, <v3>, ... */
 238                         /* [The number of parameters will determine how many */
 239                         /* names appear, and the formatter will get the */
 240                         /* commas right.] */
 241 CCM_UNPAR_DDA_2,        /* <l1> could not be parallelized because of a */
 242                         /* data dependence or aliasing of: <v2>, <v3>, ... */
 243 CCM_UNPAR_ANONDD_2,     /* <l1> could not be parallelized because of an */
 244                         /* anonymous data dependence */
 245 CCM_UNPAR_ANONDDA_2,    /* <l1> could not be parallelized because of an */
 246                         /* anonymous data dependence or aliasing */
 247 CCM_PAR_WORK_2,         /* <l1> parallelized, but might not contain */
 248                         /* enough work to run efficiently in parallel */
 249 CCM_UNPAR_EXIT_2,       /* <l1> not parallelized because it contains */
 250                         /* multiple exit points */
 251 CCM_UNPAR_STRANGE_2,    /* <l1> not parallelized because it contains a */
 252                         /* strange flow of control */
 253 CCM_UNPAR_IO_2,         /* <l1> not parallelized because it contains */
 254                         /* I/O or other MT-unsafe calls */
 255 CCM_PAR_BODY_NAME_2,    /* <l1> parallel loop-body code placed in */
 256                         /* function <p2> along with <i3> inner loops */
 257 CCM_UNPAR_NLOOPIDX_2,   /* <l1> not parallelized because loop index not */
 258                         /* found */
 259 CCM_UNPAR_DRECTV_2,     /* <l1> not parallelized because of explicit */
 260                         /* user directive */
 261 CCM_UNPAR_NOTPROFIT_2,  /* <l1> not parallelized because it was not */
 262                         /* profitable to do so */
 263 CCM_UNPAR_NEST_2,       /* <l1> not parallelized because it was */
 264                         /* nested within a parallel loop */
 265 CCM_UNPAR_2,            /* <l1> not parallelized */
 266 CCM_UNPAR_NOAUTO_2,     /* <l1> not parallelized because */
 267                         /* autoparallelization is not enabled */
 268 CCM_PR_L_VAR_2,         /* Private variables in <l1>: */
 269                         /* <v2>, <v3>, ... */
 270                         /* [The number of parameters will determine how many */
 271                         /* names appear, and the formatter will get the */
 272                         /* commas right.] */
 273 CCM_SH_L_VAR_2,         /* Shared variables in <l1>: */
 274                         /* <v2>, <v3>, ... */
 275 CCM_TP_L_VAR_2,         /* Threadprivate variables in <l1>: */
 276                         /* <v2>, <v3>, ... */
 277 CCM_RV_L_VAR_2,         /* Reduction variables of operator <s1> in <l2>: */
 278                         /* <v3>, <v4>, ... */
 279 CCM_IM_L_VAR_2,         /* Implicit variables in <l1>: */
 280                         /* <v2>, <v3>, ... */
 281 CCM_PR_O_VAR_2,         /* Private variables in <r1>: */
 282                         /* <v2>, <v3>, ... */
 283 CCM_SH_O_VAR_2,         /* Shared variables in <r1>: */
 284                         /* <v2>, <v3>, ... */
 285 CCM_TP_O_VAR_2,         /* Threadprivate variables in <r1>: */
 286                         /* <v2>, <v3>, ... */
 287 CCM_RV_O_VAR_2,         /* Reduction variables of operator <s1> in <r2>: */
 288                         /* <v3>, <v4>, ... */
 289 CCM_IM_O_VAR_2,         /* Implicit variables in <r1>: */
 290                         /* <v2>, <v3>, ... */
 291 CCM_UNPAR_IN_OMP_2,     /* <l1> not parallelized because it is inside */
 292                         /* OpenMP region <r2> */
 293 CCM_FP_O_VAR_2,         /* Firstprivate variables in <r1>: */
 294                         /* <v2>, <v3>, ... */
 295 CCM_LP_O_VAR_2,         /* Lastprivate variables in <r1>: */
 296                         /* <v2>, <v3>, ... */
 297 CCM_CP_O_VAR_2,         /* Copyprivate variables in <r1>: */
 298                         /* <v2>, <v3>, ... */
 299 CCM_PR_OAS_VAR_2,       /* Variables autoscoped as PRIVATE in <r1>: */
 300                         /* <v2>, <v3>, ... */
 301 CCM_SH_OAS_VAR_2,       /* Variables autoscoped as SHARED in <r1>: */
 302                         /* <v2>, <v3>, ... */
 303 CCM_FP_OAS_VAR_2,       /* Variables autoscoped as FIRSTPRIVATE in <r1>: */
 304                         /* <v2>, <v3>, ... */
 305 CCM_LP_OAS_VAR_2,       /* Variables autoscoped as LASTPRIVATE in <r1>: */
 306                         /* <v2>, <v3>, ... */
 307 CCM_RV_OAS_VAR_2,       /* Variables autoscoped as REDUCTION of operator */
 308                         /* <s1> in <r2>: <v3>, <v4>, ... */
 309 CCM_FAIL_OAS_VAR_2,     /* Variables treated as shared because they cannot */
 310                         /* be autoscoped in <r1>: <v2>, <v3>, ... */
 311 CCM_SERIALIZE_OAS_2,    /* <r1> will be executed by a single thread because */
 312                         /* autoscoping for some variables was not successful */
 313
 314   /* Group: Parallelization Questions asked of the user */
 315   /*    How will the user answer these questions? */
 316 CCM_QPERMVEC=0x00800,   /* Is <v1> a permutation vector during execution of */
 317                         /* <l2>? */
 318 CCM_QEXPR,              /* Is expression <s1> true for <l2>? */
 319 CCM_QSAFECALL,          /* Is subroutine <p1> MP-safe as used in <l2>? */
 320
 321   /* Group: Loop Optimization Messages */
 322 CCM_LCOST=0x01000,      /* Loop below estimated to cost <i1> cycles per */
 323                         /* iteration */
 324 CCM_UNROLL,             /* Loop below unrolled <i1> times */
 325   /* CCMV_WANT: the next one should be replaced by CCM_IMIX2 */
 326 CCM_IMIX,               /* Loop below has <i1> loads, <i2> stores, */
 327                         /* <i3> prefetches, <i4> FPadds, <i5> FPmuls, and */
 328                         /* <i6> FPdivs per iteration */
 329 CCM_SPILLS,             /* Loop below required <i1> integer register spills, */
 330                         /* <i2> FP register spills, and used */
 331                         /* <i3> integer registers and <i4> FP registers */
 332 CCM_LFISSION,           /* Loop below fissioned into <i1> loops */
 333 CCM_LPEEL,              /* Loop below had iterations peeled off for better */
 334                         /* unrolling and/or parallelization */
 335 CCM_LBLOCKED,           /* Loop below blocked by <i1> for improved cache */
 336                         /* performance */
 337 CCM_LTILED,             /* Loop below tiled for better performance */
 338 CCM_LUNRJAM,            /* Loop below unrolled and jammed */
 339 CCM_LWHILE2DO,          /* Bounds test for loop below moved to top of loop */
 340 CCM_L2CALL,             /* Loop below replaced by a call to <p1> */
 341 CCM_LDEAD,              /* Loop below deleted as dead code */
 342 CCM_LINTRCHNG,          /* Loop below interchanged with loop on line <i1> */
 343 CCM_FUSEDTO,            /* Loop below fused with loop on line <i1> */
 344 CCM_FUSEDFROM,          /* Loop from line <i1> fused with loop below */
 345 CCM_VECINTRNSC,         /* Loop below transformed to use calls to vector */
 346                         /* intrinsic <p1>, <p2>, ... */
 347                         /* [The number of parameters will determine how many */
 348                         /* names appear, and the formatter will get the */
 349                         /* commas right.] */
 350 CCM_LSTRIPMINE,         /* Loop below strip-mined */
 351 CCM_LNEST2LOOPS,        /* Loop below collapsed with loop on line <i1> */
 352 CCM_LREVERSE,           /* Loop below has had its iteration direction */
 353                         /* reversed */
 354 CCM_IMIX2,              /* Loop below has <i1> loads, <i2> stores, */
 355                         /* <i3> prefetches, <i4> FPadds, <i5> FPmuls, */
 356                         /* <i6> FPdivs, <i7> FPsubs, and <i8> FPsqrts per */
 357                         /* iteration */
 358 CCM_LUNRFULL,           /* Loop below fully unrolled */
 359 CCM_ELIM_NOAMORTINST,   /* Loop below was eliminated as it contains no */
 360                         /* non-amortizable instructions */
 361 CCM_COMP_DALIGN,        /* Performance of loop below could be improved */
 362                         /* by compiling with -dalign */
 363 CCM_INTIMIX,            /* Loop below has <i1> int-loads, <i2> int-stores, */
 364                         /* <i3> alu-ops, <i4> muls, <i5> int-divs and */
 365                         /* <i6> shifts per iteration */
 366 CCM_LMULTI_VERSION,     /* <l1> multi-versioned.  Specialized version */
 367                         /* is <l2> */
 368 CCM_LCOST_2,            /* <l1> estimated to cost <i2> cycles per iteration */
 369 CCM_UNROLL_2,           /* <l1> unrolled <i2> times */
 370
 371   /* CCMV_WANT: the next one should be replaced by CCM_IMIX2_B or CCM_IMIX3_B */
 372 CCM_IMIX_B,             /* <l1> has <i2> loads, <i3> stores, */
 373                         /* <i4> prefetches, <i5> FPadds, <i6> FPmuls, and */
 374                         /* <i7> FPdivs per iteration */
 375 CCM_SPILLS_2,           /* <l1> required <i2> integer register spills, */
 376                         /* <i3> FP register spills, and used */
 377                         /* <i4> integer registers and <i5> FP registers */
 378 CCM_LFISSION_2,         /* <l1> fissioned into <i2> loops, generating: */
 379                         /* <l3>, <l4>, ... */
 380                         /* [The number of parameters will determine how many */
 381                         /* names appear, and the formatter will get the */
 382                         /* commas right.] */
 383 CCM_LFISSION_FRAG,      /* <l1> contains code from lines: <i2>, <i3>, ... */
 384 CCM_LPEEL_2,            /* <l1> had iterations peeled off for better */
 385                         /* unrolling and/or parallelization */
 386 CCM_LBLOCKED_2,         /* <l1> blocked by <i2> for improved memory */
 387                         /* hierarchy performance, new inner loop <l3> */
 388 CCM_LOUTER_UNROLL,      /* <l1> is outer-unrolled <i2> times as part */
 389                         /* of unroll and jam */
 390 CCM_LJAMMED,            /* All <i1> copies of <l2> are fused together */
 391                         /* as part of unroll and jam */
 392 CCM_LWHILE2DO_2,        /* Bounds test for <l1> moved to top of loop */
 393 CCM_L2CALL_2,           /* <l1> replaced by a call to <p2> */
 394 CCM_LDEAD_2,            /* <l1> deleted as dead code */
 395 CCM_LINTRCHNG_2,        /* <l1> interchanged with <l2> */
 396 CCM_LINTRCHNG_ORDER,    /* For loop nest below, the final order of loops */
 397                         /* after interchanging and subsequent */
 398                         /* transformations is: <l1>, <l2>, ... */
 399                         /* [The number of parameters will determine how many */
 400                         /* names appear, and the formatter will get the */
 401                         /* commas right.] */
 402 CCM_FUSED_2,            /* <l1> fused with <l2>, new loop <l3> */
 403 CCM_VECINTRNSC_2,       /* <l1> transformed to use calls to vector */
 404                         /* intrinsics: <p2>, <p3>, ... */
 405 CCM_LSTRIPMINE_2,       /* <l1> strip-mined by <i2>, new inner loop <l3> */
 406 CCM_LNEST2LOOPS_2,      /* <l1> collapsed with <l2>, new loop <l3> */
 407 CCM_LREVERSE_2,         /* <l1> has had its iteration direction reversed */
 408 CCM_IMIX2_B,            /* <l1> has <i2> loads, <i3> stores, */
 409                         /* <i4> prefetches, <i5> FPadds, <i6> FPmuls, */
 410                         /* <i7> FPdivs, <i8> FPsubs, and <i9> FPsqrts per */
 411                         /* iteration */
 412 CCM_LUNRFULL_2,         /* <l1> fully unrolled */
 413 CCM_ELIM_NOAMORTINST_2, /* <l1> was eliminated as it contains no */
 414                         /* non-amortizable instructions */
 415 CCM_COMP_DALIGN_2,      /* Performance of <l1> could be improved by */
 416                         /* compiling with -dalign */
 417 CCM_INTIMIX_2,          /* <l1> has <i2> int-loads, <i3> int-stores, */
 418                         /* <i4> alu-ops, <i5> muls, <i6> int-divs and */
 419                         /* <i7> shifts per iteration */
 420 CCM_OMP_REGION,         /* Source OpenMP region below has tag <r1> */
 421 CCM_LMICROVECTORIZE,    /* <l1> is micro-vectorized */
 422 CCM_LMULTI_VERSION_2,   /* <l1> multi-versioned for <s2>. */
 423                         /* Specialized version is <l3> */
 424 CCM_LCLONED,            /* <l1> cloned for <s2>.  Clone is <l3> */
 425 CCM_LUNSWITCHED,        /* <l1> is unswitched.  New loops */
 426                         /* are <l2> and <l3> */
 427 CCM_LRESWITCHED,        /* Loops <l1> and <l2> and their surrounding */
 428                         /* conditional code have been merged to */
 429                         /* form loop <l3> */
 430 CCM_LSKEWBLOCKED,       /* <l1> skew-blocked by <i2> with slope */
 431                         /* <i3> for improved memory hierarchy */
 432                         /* performance, new inner loop <l4> */
 433 CCM_IVSUB,              /* Induction variable substitution performed on <l1> */
 434 CCM_ONEITER_REPLACED,   /* <l1> determined to have a trip count of 1; */
 435                         /* converted to straight-line code */
 436 CCM_IMIX3_B,            /* <l1> has <i2> loads, <i3> stores, */
 437                         /* <i4> prefetches, <i5> FPadds, <i6> FPmuls, */
 438                         /* <i7> FPmuladds, <i8> FPdivs, and <i9> FPsqrts per */
 439                         /* iteration */
 440
 441   /* Group: Pipelining Messages */
 442 CCM_PIPELINE=0x02000,   /* Loop below pipelined */
 443 CCM_PIPESTATS,          /* Loop below scheduled with steady-state cycle */
 444                         /* count = <i1> */
 445 CCM_NOPIPE_CALL,        /* Loop could not be pipelined because it contains */
 446                         /* calls */
 447 CCM_NOPIPE_INTCC,       /* Loop could not be pipelined because it sets */
 448                         /* multiple integer condition codes. */
 449 CCM_NOPIPE_MBAR,        /* Loop could not be pipelined because it contains a */
 450                         /* memory barrier instruction */
 451 CCM_NOPIPE_MNMX,        /* Loop could not be pipelined because it contains */
 452                         /* a minimum or a maximum operation */
 453 CCM_NOPIPE_U2FLT,       /* Loop could not be pipelined because it contains */
 454                         /* an unsigned to float conversion */
 455 CCM_NOPIPE_GOT,         /* Loop could not be pipelined because it sets the */
 456                         /* Global Offset Table pointer */
 457 CCM_NOPIPE_IDIV,        /* Loop could not be pipelined because it contains */
 458                         /* an integer divide */
 459 CCM_NOPIPE_PRFTCH,      /* Loop could not be pipelined because it contains */
 460                         /* a prefetch operation */
 461 CCM_NOPIPE_EXIT,        /* Loop could not be pipelined because it contains */
 462                         /* an exit operation */
 463 CCM_NOPIPE_REG,         /* Loop could not be pipelined because it contains */
 464                         /* instructions that set the %gsr or %fsr register */
 465 CCM_NOPIPE_UNS,         /* Loop could not be pipelined because it has an */
 466                         /* unsigned loop counter */
 467 CCM_NOPIPE_UNSUIT,      /* Loop was unsuitable for pipelining */
 468 CCM_NOPIPE_INTRINSIC,   /* Loop could not be pipelined because it has an */
 469                         /* intrinsic call to <p1> */
 470 CCM_NOPIPE_BIG,         /* Loop could not be pipelined as it is too big */
 471 CCM_NOPIPE_INVINTPR,    /* Loop could not be pipelined as it contains too */
 472                         /* many loop invariant integers = <i1> */
 473 CCM_NOPIPE_INVFLTPR,    /* Loop could not be pipelined as it contains too */
 474                         /* many loop invariant floats = <i1> */
 475 CCM_NOPIPE_INVDBLPR,    /* Loop could not be pipelined as it contains too */
 476                         /* many loop invariant doubles = <i1> */
 477 CCM_PIPE_SCHEDAFIPR,    /* Loop below was adversely affected by high */
 478                         /* integer register pressure = <i1> */
 479 CCM_PIPE_SCHEDAFDPR,    /* Loop below was adversely affected by high */
 480                         /* double register pressure = <i1> */
 481 CCM_PIPE_SCHEDAFFPR,    /* Loop below was adversely affected by high */
 482                         /* float register pressure = <i1> */
 483 CCM_NOPIPE_INTPR,       /* Loop could not be pipelined due to high */
 484                         /* integer register pressure = <i1> */
 485 CCM_NOPIPE_DBLPR,       /* Loop could not be pipelined due to high */
 486                         /* double register pressure = <i1> */
 487 CCM_NOPIPE_FLTPR,       /* Loop could not be pipelined due to high */
 488                         /* float register pressure = <i1> */
 489 CCM_PIPELINE_2,         /* <l1> pipelined */
 490 CCM_PIPESTATS_2,        /* <l1> scheduled with steady-state cycle */
 491                         /* count = <i2> */
 492 CCM_NOPIPE_CALL_2,      /* <l1> could not be pipelined because it contains */
 493                         /* calls */
 494 CCM_NOPIPE_INTCC_2,     /* <l1> could not be pipelined because it sets */
 495                         /* multiple integer condition codes. */
 496 CCM_NOPIPE_MBAR_2,      /* <l1> could not be pipelined because it contains */
 497                         /* a memory barrier instruction */
 498 CCM_NOPIPE_MNMX_2,      /* <l1> could not be pipelined because it contains */
 499                         /* a minimum or a maximum operation */
 500 CCM_NOPIPE_U2FLT_2,     /* <l1> could not be pipelined because it contains */
 501                         /* an unsigned to float conversion */
 502 CCM_NOPIPE_GOT_2,       /* <l1> could not be pipelined because it sets the */
 503                         /* Global Offset Table pointer */
 504 CCM_NOPIPE_IDIV_2,      /* <l1> could not be pipelined because it contains */
 505                         /* an integer divide */
 506 CCM_NOPIPE_PRFTCH_2,    /* <l1> could not be pipelined because it contains */
 507                         /* a prefetch operation */
 508 CCM_NOPIPE_EXIT_2,      /* <l1> could not be pipelined because it contains */
 509                         /* an exit operation */
 510 CCM_NOPIPE_REG_2,       /* <l1> could not be pipelined because it contains */
 511                         /* instructions that set the %gsr or %fsr register */
 512 CCM_NOPIPE_UNS_2,       /* <l1> could not be pipelined because it has an */
 513                         /* unsigned loop counter */
 514 CCM_NOPIPE_UNSUIT_2,    /* <l1> is unsuitable for pipelining */
 515 CCM_NOPIPE_INTRINSIC_2, /* <l1> could not be pipelined because it contains */
 516                         /* a call to intrinsic <p2> */
 517 CCM_NOPIPE_BIG_2,       /* <l1> could not be pipelined as it is too big */
 518 CCM_NOPIPE_INVINTPR_2,  /* <l1> could not be pipelined as it contains too */
 519                         /* many loop invariant integers = <i2> */
 520 CCM_NOPIPE_INVFLTPR_2,  /* <l1> could not be pipelined as it contains too */
 521                         /* many loop invariant floats = <i2> */
 522 CCM_NOPIPE_INVDBLPR_2,  /* <l1> could not be pipelined as it contains too */
 523                         /* many loop invariant doubles = <i2> */
 524 CCM_PIPE_SCHEDAFIPR_2,  /* <l1> was adversely affected by high */
 525                         /* integer register pressure = <i2> */
 526 CCM_PIPE_SCHEDAFDPR_2,  /* <l1> was adversely affected by high */
 527                         /* double register pressure = <i2> */
 528 CCM_PIPE_SCHEDAFFPR_2,  /* <l1> was adversely affected by high */
 529                         /* float register pressure = <i2> */
 530 CCM_NOPIPE_INTPR_2,     /* <l1> could not be pipelined due to high */
 531                         /* integer register pressure = <i2> */
 532 CCM_NOPIPE_DBLPR_2,     /* <l1> could not be pipelined due to high */
 533                         /* double register pressure = <i2> */
 534 CCM_NOPIPE_FLTPR_2,     /* <l1> could not be pipelined due to high */
 535                         /* float register pressure = <i2> */
 536
 537   /* Group: Inlining Messages */
 538 CCM_INLINE=0x04000,     /* Function <p1> inlined from source file <s2> into */
 539                         /* the code for the following line */
 540 CCM_INLINE2,            /* Function <p1> inlined from source file <s2> into */
 541                         /* inline copy of function <p3> */
 542 CCM_INLINE_TMPLT,       /* Function <p1> inlined from template file <s2> */
 543                         /* into the code for the following line */
 544 CCM_INLINE_TMPLT2,      /* Function <p1> inlined from template file <s2> */
 545                         /* into inline copy of function <p3> */
 546 CCM_INLINE_OUT_COPY,    /* Out-of-line copy of inlined function <p1> from */
 547                         /* source file <s2> generated */
 548 CCM_NINLINE_REC,        /* Recursive function <p1> inlined only up to */
 549                         /* depth <i2> */
 550 CCM_NINLINE_NEST,       /* Function <p1> not inlined because inlining is */
 551                         /* already nested too deeply */
 552 CCM_NINLINE_CMPLX,      /* Function <p1> not inlined because it contains */
 553                         /* too many operations */
 554 CCM_NINLINE_FB,         /* Function <p1> not inlined because the */
 555                         /* profile-feedback execution count is too low */
 556 CCM_NINLINE_PAR,        /* Function <p1> not inlined because it contains */
 557                         /* explicit parallel pragmas */
 558 CCM_NINLINE_OPT,        /* Function <p1> not inlined because it is */
 559                         /* compiled with optimization level <= 2 */
 560 CCM_NINLINE_USR,        /* Function <p1> not inlined because either command */
 561                         /* line option or source code pragma prohibited it, */
 562                         /* or it's not safe to inline it */
 563 CCM_NINLINE_AUTO,       /* Function <p1> not inlined because doing so */
 564                         /* would make automatic storage for <p2> too large */
 565 CCM_NINLINE_CALLS,      /* Function <p1> not inlined because it contains */
 566                         /* too many calls */
 567 CCM_NINLINE_ACTUAL,     /* Function <p1> not inlined because it has more */
 568                         /* actual parameters than formal parameters */
 569 CCM_NINLINE_FORMAL,     /* Function <p1> not inlined because it has more */
 570                         /* formal parameters than actual parameters */
 571 CCM_NINLINE_TYPE,       /* Function <p1> not inlined because formal */
 572                         /* argument type does not match actual type */
 573 CCM_NINLINE_ATYPE,      /* Function <p1> not inlined because array formal */
 574                         /* argument does not match reshaped array actual */
 575                         /* argument type */
 576 CCM_NINLINE_RETTYPE,    /* Function <p1> not inlined because return type */
 577                         /* does not match */
 578 CCM_NINLINE_EXCPT,      /* Function <p1> not inlined because it */
 579                         /* guarded by an exception handler */
 580 CCM_NINLINE_UNSAFE,     /* Function <p1> not inlined because it might be */
 581                         /* unsafe (call alloca(), etc) */
 582 CCM_NINLINE_ALIAS,      /* Function <p1> not inlined because inlining it */
 583                         /* will make the alias analysis in the calling */
 584                         /* function more conservative */
 585 CCM_NINLINE_FEMARK,     /* Function <p1> not inlined because it contains */
 586                         /* setjmp/longjmp, or indirect goto, etc */
 587 CCM_NINLINE_RAREX,      /* Function <p1> not inlined because it is known */
 588                         /* to be rarely executed */
 589 CCM_CLONING,            /* Function <p1> from source file <s2> cloned, */
 590                         /* creating cloned function <p3>; constant */
 591                         /* parameters propagated to clone */
 592 CCM_INLINE_B,           /* Function <p1> inlined from source file <s2> into */
 593                         /* the code for the following line.  <i3> loops */
 594                         /* inlined */
 595 CCM_INLINE2_B,          /* Function <p1> inlined from source file <s2> into */
 596                         /* inline copy of function <p3>.  <i4> loops inlined */
 597 CCM_INLINE_LOOP,        /* Loop in function <p1>, line <i2> has */
 598                         /* tag <l3> */
 599 CCM_NINLINE_MULTIENTRY, /* Function <p1> not inlined because it */
 600                         /* contains an ENTRY statement */
 601 CCM_NINLINE_VARARGS,    /* Function <p1> not inlined because variable */
 602                         /* argument routines cannot be inlined */
 603 CCM_NINLINE_UNSEEN_BODY,        /* Function <p1> not inlined because the compiler */
 604                         /* has not seen the body of the function.  Use */
 605                         /* -xcrossfile or -xipo in order to inline it */
 606 CCM_NINLINE_UPLEVEL,    /* Function <p1> not inlined because it is a */
 607                         /* nested routine containing references to */
 608                         /* variables defined in an outer function */
 609 CCM_NINLINE_CMDLINE,    /* Function <p1> not inlined because either */
 610                         /* -xinline or source code pragma prohibited it */
 611 CCM_NINLINE_CALL_CMPLX, /* Call to <p1> not inlined because of the */
 612                         /* complexity of the calling routine */
 613 CCM_NINLINE_LANG_MISMATCH,      /* Call to <p1> not inlined because it is in */
 614                         /* a different language */
 615 CCM_NINLINE_RTN_WEAK,   /* Function <p1> not inlined because it */
 616                         /* is marked weak */
 617 CCM_NINLINE_CALL_WEAKFILE,      /* Call to <p1> not inlined because it is */
 618                         /* in a different file and it contains a */
 619                         /* call to a weak routine */
 620 CCM_NINLINE_CALL_TRYCATCH,      /* Call to <p1> not inlined because it is */
 621                         /* in a different file and contains an */
 622                         /* explicit try/catch */
 623 CCM_NINLINE_CALL_REGP,  /* Call to <p1> not inlined because it would */
 624                         /* cause excessive register pressure */
 625 CCM_NINLINE_RTN_REGP,   /* Function <p1> not inlined because it would */
 626                         /* cause excessive register pressure */
 627 CCM_NINLINE_CALL_XPENSV,        /* Call to <p1> not inlined because analysis */
 628                         /* exceeds the compilation time limit */
 629 CCM_NINLINE_READONLYIR, /* Function <p1> not inlined because it is in a file */
 630                         /* specified as read-only by -xipo_archive=readonly */
 631                         /* and it contains calls to static functions */
 632 CCM_NINLINE_CALL_THUNK, /* Call to <p1> not inlined because it is in a */
 633                         /* compiler-generated function that does not */
 634                         /* permit inlining */
 635 CCM_NINLINE_CALL_XTARGETS,      /* Indirect callsite has too many targets; */
 636                         /* callsite marked do not inline */
 637 CCM_NINLINE_SELFTAIL_RECURSIVE, /* Function <p1> not inlined because */
 638                         /* of a recursive tail-call to itself */
 639 CCM_NINLINE_PRAGMA,     /* Function <p1> not inlined because it contains */
 640                         /* explicit parallel or alias pragmas */
 641 CCM_NINLINE_CMPLX2,     /* Function <p1> not inlined because it contains too */
 642                         /* many operations.  Increase max_inst_hard in order */
 643                         /* to inline it: -xinline_param=max_inst_hard:n */
 644 CCM_NINLINE_RARE,       /* Function <p1> not inlined because the call */
 645                         /* is rarely executed */
 646 CCM_NINLINE_PAR2,       /* Function <p1> not inlined because it is called */
 647                         /* within a region guarded by an explicit */
 648                         /* parallel pragmas */
 649 CCM_NINLINE_G_LIMIT,    /* Function <p1> not inlined because it would exceed */
 650                         /* the permitted global code size growth limit.  Try */
 651                         /* to increase max_growth in order to inline it: */
 652                         /* -xinline_param=max_growth:n */
 653 CCM_NINLINE_L_LIMIT,    /* Function <p1> not inlined because it would exceed */
 654                         /* the maximum function size growth limit.  Increase */
 655                         /* max_function_inst in order to inline it: */
 656                         /* -xinline_param=max_function_inst:n */
 657 CCM_NINLINE_REC2,       /* Recursive function <p1> is inlined only up to */
 658                         /* <i2> levels and up to <i3> size.  Increase */
 659                         /* max_recursive_deptha or max_recursive_inst in */
 660                         /* order to inline it: */
 661                         /* -xinline_param=max_recursive_depth:n, */
 662                         /* -xinline_param=max_recursive_inst:n */
 663 CCM_NINLINE_FB2,        /* Function <p1> not inlined because the */
 664                         /* profile-feedback execution count is too */
 665                         /* low.  Decrease min_counter in order to inline it: */
 666                         /* -xinline_param:min_counter:n */
 667 CCM_NINLINE_CS_CMPLX,   /* Function <p1> not inlined because called */
 668                         /* function's size is too big.  Increase */
 669                         /* max_inst_soft in order to inline it: */
 670                         /* -xinline_param=max_inst_soft:n */
 671 CCM_NINLINE_R_EXCPT,    /* Function <p1> not inlined because it contains */
 672                         /* an exception handler */
 673 CCM_NINLINE_ASM,        /* Function <p1> not inlined because */
 674                         /* it contains asm statements */
 675 CCM_NINLINE_R_READONLYIR,       /* Function <p1> not inlined because it is in a file */
 676                         /* specified as read-only by -xipo_archive=readonly */
 677                         /* and it is a static function */
 678 CCM_NINLINE_C_READONLYIR,       /* Call to <p1> not inlined because the calling */
 679                         /* function is in a file specified as read-only */
 680                         /* by -xipo_archive=readonly */
 681 CCM_NINLINE_NEVERRETURN,        /* Function <p1> not inlined because it */
 682                         /* never returns */
 683
 684   /* Group: Messages Concerning Memory Operations */
 685   /*    Notes: */
 686   /*    a.  In all of these, <s1> is a string that is something like */
 687   /*    "A(i+5*k)" or "structure.field", giving the high-level */
 688   /*    construct that is being loaded or stored. */
 689   /*     */
 690   /*    b.  In all of these, <x2> refers to an instruction offset, */
 691   /*    expressed as a 32-bit signed integer.  It is assumed */
 692   /*    that any prefetches will be within this range of the */
 693   /*    load/store they are prefetching for. */
 694 CCM_MPREFETCH=0x08000,  /* Prefetch of <s1> inserted */
 695                         /* [This message has a lineno for the source, */
 696                         /* but no instaddr for the disassembly.] */
 697 CCM_MPREFETCH_LD,       /* Prefetch of <s1> inserted for load at <x2> */
 698                         /* [This message has lineno = -1, */
 699                         /* and is for disassembly only] */
 700 CCM_MPREFETCH_ST,       /* Prefetch of <s1> inserted for store at <x2> */
 701                         /* [This message has lineno = -1, */
 702                         /* and is for disassembly only] */
 703 CCM_MPREFETCH_FB,       /* Prefetch of <s1> inserted based on feedback data */
 704                         /* [This message has a lineno for the source, */
 705                         /* but no instaddr for the disassembly.] */
 706 CCM_MPREFETCH_FB_LD,    /* Prefetch of <s1> inserted for load at <x2> based */
 707                         /* on feedback data */
 708                         /* [This message has lineno = -1, */
 709                         /* and is for disassembly only] */
 710 CCM_MPREFETCH_FB_ST,    /* Prefetch of <s1> inserted for store at <x2> based */
 711                         /* on feedback data */
 712                         /* [This message has lineno = -1, */
 713                         /* and is for disassembly only] */
 714 CCM_MLOAD,              /* Load below refers to <s1> */
 715                         /* [This message has lineno = -1, */
 716                         /* and is for disassembly only] */
 717 CCM_MSTORE,             /* Store below refers to <s1> */
 718                         /* [This message has lineno = -1, */
 719                         /* and is for disassembly only] */
 720 CCM_MLOAD_P,            /* Load below refers to <s1>, and was prefetched */
 721                         /* at <x2> */
 722                         /* [This message has lineno = -1, */
 723                         /* and is for disassembly only] */
 724 CCM_MSTORE_P,           /* Store below refers to <s1>, and was prefetched */
 725                         /* at <x2> */
 726                         /* [This message has lineno = -1, */
 727                         /* and is for disassembly only] */
 728
 729   /* Group: Front-end messages [all compilers] */
 730   /* Group: F95 Front-end Messages */
 731 CCM_COPYIN=0x10000,     /* Parameter <i1> caused a copyin in the following */
 732                         /* call */
 733 CCM_COPYOUT,            /* Parameter <i1> caused a copyout in the following */
 734                         /* call */
 735 CCM_COPYINOUT,          /* Parameter <i1> caused both a copyin and copyout */
 736                         /* in the following call */
 737 CCM_PADDING,            /* Padding of <i1> bytes inserted before */
 738                         /* array <v2> */
 739 CCM_PADCOMMON,          /* Padding of <i1> bytes inserted before */
 740                         /* array <v2> in common block <v3> */
 741 CCM_ALIGN_EQ,           /* Variable/array <v1> can not be double-aligned, */
 742                         /* because it is equivalenced */
 743 CCM_ALIGN_PERF,         /* Alignment of variables in common block may cause */
 744                         /* performance degradation */
 745 CCM_ALIGN_STRUCT,       /* Alignment of component <s1> in numeric sequence */
 746                         /* structure <s2> may cause performance degradation */
 747 CCM_TMP_COPY,           /* Argument <v1> copied to a temporary */
 748 CCM_TMP_COPYM,          /* Argument <v1> might be copied to a temporary; */
 749                         /* runtime decision made */
 750 CCM_PROC_MISMATCH,      /* Argument <i1> to subprogram <p2> differs from */
 751                         /* reference on line <i3> */
 752 CCM_PROC_MISMATCH2,     /* Scalar argument <i1> to subprogram <p2> is */
 753                         /* referred to as an array on line <i3> */
 754 CCM_PROC_MISMATCH3,     /* Return type/rank from subprogram <p1> differs */
 755                         /* from return on line <i2> */
 756 CCM_DO_EXPR,            /* DO statement bounds lead to no executions of the */
 757                         /* loop */
 758 CCM_AUTO_BND,           /* The bounds for automatic variable <v1> are not */
 759                         /* available at all entry points; zero-length */
 760                         /* variable might be allocated */
 761 CCM_LIT_PAD,            /* The character string literal <s1> padded */
 762                         /* to the length specified for the dummy argument */
 763 CCM_ARRAY_LOOP,         /* Array statement below generated a loop */
 764 CCM_ARRAY_LOOPNEST,     /* Array statement below generated <i1> nested loops */
 765 CCM_ALIGN_PERF2,        /* Alignment of variable <v1> in common block <v2> */
 766                         /* may cause a performance degradation */
 767 CCM_ALIGN_PERF3,        /* Alignment of variable <v1> in blank common may */
 768                         /* cause a performance degradation */
 769 CCM_IO_LOOP_ARRAY,      /* I/O implied do item below generated an array */
 770                         /* section */
 771
 772   /* Group: C++ Front-end Messages */
 773 CCM_TMPCONST,           /* Implicit invocation of class <s1> constructor for */
 774                         /* temporary */
 775 CCM_TMPDEST,            /* Implicit invocation of class <s1> destructor for */
 776                         /* temporary */
 777 CCM_DBL_CONST,          /* Double constant <s1> used in float expression */
 778 CCM_MINLINE,            /* Function <p1> inlined from source file <s2> by */
 779                         /* front-end */
 780                         /* [This refers to front-end inlining, */
 781                         /* not the backend inlining above.] */
 782 CCM_MINLINE2,           /* Function <p1> from source file <s2> inlined into */
 783                         /* inline copy of method <p3> by front-end */
 784                         /* [This refers to front-end inlining, */
 785                         /* not the backend inlining above.] */
 786 CCM_MINLINE3,           /* Function <p1> not inlined because it uses keyword */
 787                         /* <s2> */
 788 CCM_MINLINE4,           /* Function <p1> not inlined because it is too */
 789                         /* complex */
 790 CCM_TMP_COPYOUT,        /* Argument <v1> copied from a temporary */
 791 CCM_TMP_COPYOUTM,       /* Argument <v1> might be copied from a temporary; */
 792                         /* runtime decision made */
 793 CCM_TMP_COPYINOUT,      /* Argument <v1> copied in and out of a temporary */
 794 CCM_TMP_COPYINOUTM,     /* Argument <v1> might be copied in and out of */
 795                         /* a temporary; runtime decision made */
 796
 797   /* Group: C Front-end Messages */
 798   /* Group: NJC Front-end Messages */
 799   /* Group: Updated F95 Front-end Messages */
 800 CCM_ARRAY_LOOP_2,       /* Array statement below generated loop <l1> */
 801 CCM_ARRAY_LOOPNEST_2,   /* Array statement below generated <i1> nested */
 802                         /* loops: <l2>, <l3>, ... */
 803                         /* [The number of parameters will determine how many */
 804                         /* names appear, and the formatter will get the */
 805                         /* commas right.] */
 806 CCM_IO_LOOP_ARRAY_2,    /* I/O implied do item below generated an array */
 807                         /* section: <l1> */
 808 CCM_USER_LOOP,          /* Source loop below has tag <l1> */
 809 CCM_FOUND_LOOP,         /* Discovered loop below has tag <l1> */
 810 CCM_MFUNCTION_LOOP,     /* Copy in M-function of loop below has tag <l1> */
 811
 812   /* Group: Code-generator Messages */
 813 CCM_FSIMPLE=0x20000,    /* Transformations for fsimple=<i1> applied */
 814 CCM_STACK,              /* Function <p1> requires <i2> Mbytes of stack */
 815                         /* storage */
 816 CCM_TAILRECUR,          /* Recursive tail call in <p1> optimized to jump to */
 817                         /* entry point */
 818 CCM_TAILCALL,           /* Call to function <p1> was tail-call optimized */
 819 CCM_NI_EXIT_OR_PSEUDO,  /* Template could not be early inlined because it */
 820                         /* contains the pseudo instruction <s1> */
 821 CCM_NI_BAD_UNARY_OPC,   /* Template could not be early inlined because it */
 822                         /* contains the instruction opcode <s1> */
 823 CCM_NI_INT_LDD_ON_V9,   /* Template could not be early inlined because it */
 824                         /* contains integer ldd instructions, which are */
 825                         /* deprecated in the v9 architecture */
 826 CCM_NI_LATE_INL_OPC,    /* Template could not be early inlined because it */
 827                         /* contains the instruction opcode <s1> */
 828 CCM_NI_BAD_IMM_OP,      /* Template could not be early inlined because the */
 829                         /* relocation or immediate operand <s1> is not well */
 830                         /* understood by the optimizer */
 831 CCM_NI_BAD_STATELEAF,   /* Template could not be early inlined because it */
 832                         /* references the state register <s1> */
 833 CCM_NI_BAD_ASR_19,      /* Template could not be early inlined because */
 834                         /* %asr19 is not supported in pre v8plus code */
 835 CCM_NI_BAD_FSR_USE,     /* Template could not be early inlined because */
 836                         /* references to %fsr can only be optimized when the */
 837                         /* -iaopts flag is used */
 838 CCM_NI_BAD_REGISTER,    /* Template could not be early inlined because it */
 839                         /* references the register <s1> */
 840 CCM_NI_NO_RET_VAL,      /* Template could not be early inlined because it */
 841                         /* does not return the value declared */
 842 CCM_NI_DELAY,           /* Template could not be early inlined because it */
 843                         /* contains a non nop delay slot */
 844 CCM_NI_SCALL,           /* Template could not be early inlined because it */
 845                         /* calls a function which returns a structure */
 846 CCM_CASE_POSITION,      /* Case block below was placed at position <i1> */
 847                         /* based on execution frequency */
 848 CCM_CALL_WITH_CODE,     /* Call to <p1> replaced with inline code.  <i2> */
 849                         /* loops created: <l3>, <l4>, ... */
 850 CCM_NI_BAD_SP_ADDR,     /* Template could not be early inlined because it */
 851                         /* contains a %sp+reg address */
 852 CCM_NI_BAD_SP_USAGE,    /* Template could not be early inlined because it */
 853                         /* uses/defines the stack pointer in a non-load/store instruction */
 854 CCM_NI_MIXED_REG_TYPES, /* Template could not be early inlined because it */
 855                         /* contains register <s1> used as both x-register and register pair */
 856 CCM_LAST
 857 } COMPMSG_ID;
 858 /*
 859  * The Message Structure
 860  * Each message is a fixed-length structure as follows:
 861  */
 862 typedef struct
 863 {
 864   int64_t instaddr;     /* the PC offset, relative to the .o .text section */
 865   int32_t lineno;       /* the source line to which it refers */
 866   COMPMSG_ID msg_type;  /* the specific message index */
 867   int32_t nparam;       /* number of parameters to this message */
 868   int32_t param_index;  /* the index of the first parameter */
 869 } compmsg;
 870
 871 #if defined(__cplusplus)
 872 extern "C"
 873 {
 874 #endif
 875   /*
 876    * Initializes the data structures, converts the source name to a string,
 877    * and fills in srcname and version in the header
 878    */
 879   void compcom_p_open (char *srcname, int32_t version);
 880
 881   /*
 882    * Finds or enters the string s into the string table, and returns the index
 883    * of the string
 884    */
 885   int32_t compcom_p_string (char *s);
 886
 887   /*
 888    * Enter the single message.  Any string parameters should have been converted
 889    * to int32's by calling compcom_p_string()
 890    */
 891   void compcom_p_putmsg (int32_t show_bits, int64_t pcoffset, int32_t lineno,
 892                          COMPMSG_ID m, int32_t nparams);
 893
 894   /*
 895    * Whatever is needed to close the section and write it out to the .o
 896    */
 897   void compcom_p_finalize ();
 898
 899 #if defined(__cplusplus)
 900 }
 901 #endif
 902
 903 #endif /* _COMP_COM_H */