vasilito
ff4ff35918
Red Bear OS is a full fork. All sources must be available from git clone with zero network access. Removed gitignore rules that excluded fetched source trees under recipes/*/source/, local/recipes/kde/*/source/, local/recipes/qt/*/source/, and vendor source trees. Build artifacts (target/, build/, source.tar, *.o, *.so) remain excluded. 127291 files added — kernel, relibc, base, bootloader, pkgar, all KDE/Qt frameworks, mesa, wayland, DRM drivers, and every other recipe source.
904 lines
44 KiB
C
904 lines
44 KiB
C
/* Copyright (C) 2021-2024 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 */
|