/* Copyright (C) 2021 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 */