mirror of
https://github.com/autc04/Retro68.git
synced 2024-06-07 13:33:06 +00:00
3482 lines
129 KiB
C
3482 lines
129 KiB
C
/* 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. */
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <locale.h>
|
|
#include <values.h>
|
|
#include <assert.h>
|
|
|
|
#include "comp_com.h"
|
|
|
|
/*
|
|
* To add a new message _FORMAT_ please perform the following tasks:
|
|
* 1) Insert it into the list below, with the matching comment.
|
|
* The table is sorted by parameter type. In increasing order
|
|
* they are: String, Procedure, Variable, Loop, Region, Integer.
|
|
* 2) Insert the corresponding information into the following
|
|
* procedures in this file: ccm_num_params(), ccm_paramlist_index(),
|
|
* ccm_param_primtype(), and ccm_param_hightype().
|
|
* 3) If you are also creating a new high-type or primitive-type,
|
|
* extend the corresponding enum, update this comment and make sure
|
|
* to update any code in the analyzer, iropt, cg or ube that depends
|
|
* on knowing the limited set of types.
|
|
*/
|
|
|
|
typedef enum ccm_fmt {
|
|
CCMFMT_NONE, /* none */
|
|
CCMFMT_S1, /* s1 */
|
|
CCMFMT_S1S2, /* s1, s2 */
|
|
CCMFMT_S1L2, /* s1, l2 */
|
|
CCMFMT_S1L2VV3, /* s1, l2, v3, v4, ... */
|
|
CCMFMT_S1R2VV3, /* s1, r2, v3, v4, ... */
|
|
CCMFMT_S1X2, /* s1, x2 */
|
|
CCMFMT_P1, /* p1 */
|
|
CCMFMT_P1S2, /* p1, s2 */
|
|
CCMFMT_P1S2P3, /* p1, s2, p3 */
|
|
CCMFMT_P1S2P3I4, /* p1, s2, p3, i4 */
|
|
CCMFMT_P1S2I3, /* p1, s2, i3 */
|
|
CCMFMT_P1P2, /* p1, p2 */
|
|
CCMFMT_P1L2, /* p1, l2 */
|
|
CCMFMT_P1I2, /* p1, i2 */
|
|
CCMFMT_P1I2L3, /* p1, i2, l3 */
|
|
CCMFMT_P1I2LL3, /* p1, i2, l3, l4 ... */
|
|
CCMFMT_P1I2I3, /* p1, i2, i3 */
|
|
CCMFMT_PP1, /* p1, p2, ... */
|
|
CCMFMT_V1, /* v1 */
|
|
CCMFMT_V1V2, /* v1, v2 */
|
|
CCMFMT_V1L2, /* v1, l2 */
|
|
CCMFMT_VV1, /* v1, v2, ... */
|
|
CCMFMT_L1, /* l1 */
|
|
CCMFMT_L1S2, /* l1, s2 */
|
|
CCMFMT_L1S2L3, /* l1, s2, l3 */
|
|
CCMFMT_L1P2, /* l1, p2 */
|
|
CCMFMT_L1P2I3, /* l1, p2, i3 */
|
|
CCMFMT_L1PP2, /* l1, p2, p3, ... */
|
|
CCMFMT_L1VV2, /* l1, v2, v3, ... */
|
|
CCMFMT_L1L2, /* l1, l2 */
|
|
CCMFMT_L1L2L3, /* l1, l2, l3 */
|
|
CCMFMT_LL1, /* l1, l2, ... */
|
|
CCMFMT_L1R2, /* l1, r2 */
|
|
CCMFMT_L1I2, /* l1, i2 */
|
|
CCMFMT_L1I2L3, /* l1, i2, l3 */
|
|
CCMFMT_L1I2LL3, /* l1, i2, l3, l4, ... */
|
|
CCMFMT_L1I2I3L4, /* l1, i2, i3, l4 */
|
|
CCMFMT_L1I2I3I4I5, /* l1, i2, ..., i5 */
|
|
CCMFMT_L1I2I3I4I5I6I7, /* l1, i2, ..., i7 */
|
|
CCMFMT_L1I2I3I4I5I6I7I8I9, /* l1, i2, ..., i9 */
|
|
CCMFMT_L1II2, /* l1, i2, i3, ... */
|
|
CCMFMT_R1, /* r1 */
|
|
CCMFMT_R1VV2, /* r1, v2, v3, ... */
|
|
CCMFMT_I1, /* i1 */
|
|
CCMFMT_I1P2I3, /* i1, p2, i3 */
|
|
CCMFMT_I1V2, /* i1, v2 */
|
|
CCMFMT_I1V2V3, /* i1, v2, v3 */
|
|
CCMFMT_I1L2, /* i1, l2 */
|
|
CCMFMT_I1LL2, /* i1, l2, l3, ... */
|
|
CCMFMT_I1I2I3I4, /* i1, i2, i3, i4 */
|
|
CCMFMT_I1I2I3I4I5I6, /* i1, i2, ..., i6 */
|
|
CCMFMT_I1I2I3I4I5I6I7I8, /* i1, i2, ..., i8 */
|
|
CCMFMT_LAST
|
|
} Ccm_Fmttype_t;
|
|
|
|
/*
|
|
* Low- and high-level types for commentary parameters.
|
|
*/
|
|
|
|
typedef enum ccm_primtype
|
|
{
|
|
CCM_PRIMTYPE_NONE,
|
|
CCM_PRIMTYPE_STRING,
|
|
CCM_PRIMTYPE_INTEGER,
|
|
CCM_PRIMTYPE_HEXSTRING
|
|
} Ccm_Primtype_t;
|
|
|
|
typedef enum ccm_hightype
|
|
{
|
|
CCM_HITYPE_NONE,
|
|
CCM_HITYPE_STRING,
|
|
CCM_HITYPE_PROCEDURE,
|
|
CCM_HITYPE_VARIABLE,
|
|
CCM_HITYPE_LOOPTAG,
|
|
CCM_HITYPE_REGIONTAG,
|
|
CCM_HITYPE_HEXSTRING,
|
|
CCM_HITYPE_INTEGER
|
|
} Ccm_Hitype_t;
|
|
|
|
typedef struct ccm_attrs
|
|
{
|
|
char *msg; /* I18N msg string */
|
|
const char *name; /* Print name for this message ID */
|
|
int32_t vis; /* Visibility bits */
|
|
Ccm_Fmttype_t fmt; /* Format type */
|
|
} Ccm_Attr_t;
|
|
|
|
static Ccm_Attr_t *ccm_attrs; /* Table of per-msg attributes */
|
|
static nl_catd ccm_catd = (nl_catd) - 1; /* messages id */
|
|
|
|
/*
|
|
* map COMPMSG_ID to table indices
|
|
*/
|
|
static int
|
|
ccm_vis_index (COMPMSG_ID m)
|
|
{
|
|
int32_t high = m >> 8;
|
|
int32_t low = m & 0xFF;
|
|
for (int i = 0; i < 24; i++, high >>= 1)
|
|
if (high <= 1)
|
|
return (i << 8) + low + 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Return # parameters for this message; MAXINT for messages with
|
|
* parameter lists.
|
|
*/
|
|
static int
|
|
ccm_num_params (COMPMSG_ID m)
|
|
{
|
|
int vindex;
|
|
int res;
|
|
vindex = ccm_vis_index (m);
|
|
switch (ccm_attrs[vindex].fmt)
|
|
{
|
|
case CCMFMT_NONE:
|
|
res = 0;
|
|
break;
|
|
case CCMFMT_S1:
|
|
case CCMFMT_P1:
|
|
case CCMFMT_V1:
|
|
case CCMFMT_L1:
|
|
case CCMFMT_R1:
|
|
case CCMFMT_I1:
|
|
res = 1;
|
|
break;
|
|
case CCMFMT_S1S2:
|
|
case CCMFMT_S1L2:
|
|
case CCMFMT_S1X2:
|
|
case CCMFMT_P1S2:
|
|
case CCMFMT_P1P2:
|
|
case CCMFMT_P1L2:
|
|
case CCMFMT_P1I2:
|
|
case CCMFMT_V1V2:
|
|
case CCMFMT_V1L2:
|
|
case CCMFMT_L1S2:
|
|
case CCMFMT_L1P2:
|
|
case CCMFMT_L1L2:
|
|
case CCMFMT_L1R2:
|
|
case CCMFMT_L1I2:
|
|
case CCMFMT_I1V2:
|
|
case CCMFMT_I1L2:
|
|
res = 2;
|
|
break;
|
|
case CCMFMT_P1S2P3:
|
|
case CCMFMT_P1S2I3:
|
|
case CCMFMT_P1I2L3:
|
|
case CCMFMT_P1I2I3:
|
|
case CCMFMT_L1S2L3:
|
|
case CCMFMT_L1P2I3:
|
|
case CCMFMT_L1L2L3:
|
|
case CCMFMT_L1I2L3:
|
|
case CCMFMT_I1P2I3:
|
|
case CCMFMT_I1V2V3:
|
|
res = 3;
|
|
break;
|
|
case CCMFMT_P1S2P3I4:
|
|
case CCMFMT_L1I2I3L4:
|
|
case CCMFMT_I1I2I3I4:
|
|
res = 4;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5:
|
|
res = 5;
|
|
break;
|
|
case CCMFMT_I1I2I3I4I5I6:
|
|
res = 6;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5I6I7:
|
|
res = 7;
|
|
break;
|
|
case CCMFMT_I1I2I3I4I5I6I7I8:
|
|
res = 8;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5I6I7I8I9:
|
|
res = 9;
|
|
break;
|
|
case CCMFMT_S1L2VV3:
|
|
case CCMFMT_S1R2VV3:
|
|
case CCMFMT_PP1:
|
|
case CCMFMT_P1I2LL3:
|
|
case CCMFMT_VV1:
|
|
case CCMFMT_L1PP2:
|
|
case CCMFMT_L1VV2:
|
|
case CCMFMT_LL1:
|
|
case CCMFMT_L1I2LL3:
|
|
case CCMFMT_L1II2:
|
|
case CCMFMT_R1VV2:
|
|
case CCMFMT_I1LL2:
|
|
res = MAXINT;
|
|
break;
|
|
case CCMFMT_LAST:
|
|
default:
|
|
/* programming failure */
|
|
/* if(1) is hack to get around warning from C++ compiler */
|
|
if (1) assert (0);
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static int
|
|
ccm_paramlist_index (COMPMSG_ID m)
|
|
{
|
|
int res;
|
|
int vindex = ccm_vis_index (m);
|
|
switch (ccm_attrs[vindex].fmt)
|
|
{
|
|
case CCMFMT_NONE:
|
|
case CCMFMT_S1:
|
|
case CCMFMT_S1S2:
|
|
case CCMFMT_S1L2:
|
|
case CCMFMT_S1X2:
|
|
case CCMFMT_P1:
|
|
case CCMFMT_P1S2:
|
|
case CCMFMT_P1S2P3:
|
|
case CCMFMT_P1S2P3I4:
|
|
case CCMFMT_P1S2I3:
|
|
case CCMFMT_P1P2:
|
|
case CCMFMT_P1L2:
|
|
case CCMFMT_P1I2:
|
|
case CCMFMT_P1I2L3:
|
|
case CCMFMT_P1I2I3:
|
|
case CCMFMT_V1:
|
|
case CCMFMT_V1V2:
|
|
case CCMFMT_V1L2:
|
|
case CCMFMT_L1:
|
|
case CCMFMT_L1S2:
|
|
case CCMFMT_L1S2L3:
|
|
case CCMFMT_L1P2:
|
|
case CCMFMT_L1P2I3:
|
|
case CCMFMT_L1L2:
|
|
case CCMFMT_L1L2L3:
|
|
case CCMFMT_L1R2:
|
|
case CCMFMT_L1I2:
|
|
case CCMFMT_L1I2L3:
|
|
case CCMFMT_L1I2I3L4:
|
|
case CCMFMT_L1I2I3I4I5:
|
|
case CCMFMT_L1I2I3I4I5I6I7:
|
|
case CCMFMT_L1I2I3I4I5I6I7I8I9:
|
|
case CCMFMT_R1:
|
|
case CCMFMT_I1:
|
|
case CCMFMT_I1P2I3:
|
|
case CCMFMT_I1V2:
|
|
case CCMFMT_I1V2V3:
|
|
case CCMFMT_I1L2:
|
|
case CCMFMT_I1I2I3I4:
|
|
case CCMFMT_I1I2I3I4I5I6:
|
|
case CCMFMT_I1I2I3I4I5I6I7I8:
|
|
res = 0;
|
|
break;
|
|
case CCMFMT_PP1:
|
|
case CCMFMT_VV1:
|
|
case CCMFMT_LL1:
|
|
res = 1;
|
|
break;
|
|
case CCMFMT_L1PP2:
|
|
case CCMFMT_L1VV2:
|
|
case CCMFMT_L1II2:
|
|
case CCMFMT_R1VV2:
|
|
case CCMFMT_I1LL2:
|
|
res = 2;
|
|
break;
|
|
case CCMFMT_S1L2VV3:
|
|
case CCMFMT_S1R2VV3:
|
|
case CCMFMT_P1I2LL3:
|
|
case CCMFMT_L1I2LL3:
|
|
res = 3;
|
|
break;
|
|
case CCMFMT_LAST:
|
|
default:
|
|
/* programming failure */
|
|
/* if(1) is hack to get around warning from C++ compiler */
|
|
if (1) assert (0);
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static Ccm_Primtype_t
|
|
ccm_param_primtype (COMPMSG_ID m, int param_idx)
|
|
{
|
|
int vindex;
|
|
Ccm_Primtype_t res;
|
|
if (param_idx <= 0 || param_idx > ccm_num_params (m))
|
|
return CCM_PRIMTYPE_NONE;
|
|
|
|
res = CCM_PRIMTYPE_NONE; /* should always be updated */
|
|
vindex = ccm_vis_index (m);
|
|
switch (ccm_attrs[vindex].fmt)
|
|
{
|
|
/*
|
|
* Sort cases by:
|
|
* 1) # parameters
|
|
* 2) Strings before Integers
|
|
* 3) Enum tags
|
|
*/
|
|
case CCMFMT_NONE:
|
|
/* programming failure */
|
|
/* if(1) is hack to get around warning from C++ compiler */
|
|
if (1)
|
|
assert (0);
|
|
break;
|
|
case CCMFMT_S1:
|
|
case CCMFMT_P1:
|
|
case CCMFMT_V1:
|
|
case CCMFMT_L1:
|
|
case CCMFMT_R1:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_I1:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_S1S2:
|
|
case CCMFMT_S1L2:
|
|
case CCMFMT_P1S2:
|
|
case CCMFMT_P1P2:
|
|
case CCMFMT_P1L2:
|
|
case CCMFMT_V1V2:
|
|
case CCMFMT_V1L2:
|
|
case CCMFMT_L1S2:
|
|
case CCMFMT_L1P2:
|
|
case CCMFMT_L1L2:
|
|
case CCMFMT_L1R2:
|
|
if (param_idx == 1 || param_idx == 2)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_S1X2:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_PRIMTYPE_HEXSTRING;
|
|
break;
|
|
case CCMFMT_P1I2:
|
|
case CCMFMT_L1I2:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1V2:
|
|
case CCMFMT_I1L2:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
else if (param_idx == 2)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_P1S2P3:
|
|
case CCMFMT_L1S2L3:
|
|
case CCMFMT_L1L2L3:
|
|
if (param_idx >= 1 && param_idx <= 3)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_P1S2I3:
|
|
case CCMFMT_L1P2I3:
|
|
if (param_idx == 1 || param_idx == 2)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 3)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1I2L3:
|
|
case CCMFMT_L1I2L3:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1I2I3:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 2 || param_idx == 3)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1V2V3:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
else if (param_idx == 2 || param_idx == 3)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_I1P2I3:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
else if (param_idx == 2)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_L1I2I3L4:
|
|
if (param_idx == 1 || param_idx == 4)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 2 || param_idx == 3)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1S2P3I4:
|
|
if (param_idx >= 1 && param_idx <= 3)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx == 4)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1I2I3I4:
|
|
if (param_idx >= 1 && param_idx <= 4)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx >= 2 && param_idx <= 5)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1I2I3I4I5I6:
|
|
if (param_idx >= 1 && param_idx <= 6)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5I6I7:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx >= 2 && param_idx <= 7)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1I2I3I4I5I6I7I8:
|
|
if (param_idx >= 1 && param_idx <= 8)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5I6I7I8I9:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else if (param_idx >= 2 && param_idx <= 9)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_S1L2VV3:
|
|
case CCMFMT_S1R2VV3:
|
|
case CCMFMT_PP1:
|
|
case CCMFMT_VV1:
|
|
case CCMFMT_L1PP2:
|
|
case CCMFMT_L1VV2:
|
|
case CCMFMT_LL1:
|
|
case CCMFMT_R1VV2:
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_P1I2LL3:
|
|
case CCMFMT_L1I2LL3:
|
|
if (param_idx == 2)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
else
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_L1II2:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_STRING;
|
|
else
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1LL2:
|
|
if (param_idx == 1)
|
|
res = CCM_PRIMTYPE_INTEGER;
|
|
else
|
|
res = CCM_PRIMTYPE_STRING;
|
|
break;
|
|
case CCMFMT_LAST:
|
|
default:
|
|
/* programming failure */
|
|
/* if(1) is hack to get around warning from C++ compiler */
|
|
if (1)
|
|
assert (0);
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static Ccm_Hitype_t
|
|
ccm_param_hightype (COMPMSG_ID m, int param_idx)
|
|
{
|
|
int vindex;
|
|
Ccm_Hitype_t res;
|
|
|
|
if (param_idx <= 0 || param_idx > ccm_num_params (m))
|
|
return CCM_HITYPE_NONE;
|
|
res = CCM_HITYPE_NONE; /* should always be updated */
|
|
vindex = ccm_vis_index (m);
|
|
switch (ccm_attrs[vindex].fmt)
|
|
{
|
|
case CCMFMT_NONE:
|
|
/* programming failure */
|
|
/* if(1) is hack to get around warning from C++ compiler */
|
|
if (1)
|
|
assert (0);
|
|
break;
|
|
case CCMFMT_S1:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_S1S2:
|
|
if (param_idx == 1 || param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_S1L2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_S1L2VV3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_S1R2VV3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_REGIONTAG;
|
|
else
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_S1X2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_STRING;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_HEXSTRING;
|
|
break;
|
|
case CCMFMT_P1:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
break;
|
|
case CCMFMT_P1S2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_P1S2P3:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_P1S2P3I4:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
else if (param_idx == 4)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1S2I3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
else if (param_idx == 3)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1P2:
|
|
if (param_idx == 1 || param_idx == 2)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
break;
|
|
case CCMFMT_P1L2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_P1I2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1I2L3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else if (param_idx == 3)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_P1I2I3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2 || param_idx == 3)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_P1I2LL3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_PP1:
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
break;
|
|
case CCMFMT_V1:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_V1V2:
|
|
if (param_idx == 1 || param_idx == 2)
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_V1L2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_VARIABLE;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_VV1:
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_L1:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_L1S2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_L1S2L3:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_STRING;
|
|
break;
|
|
case CCMFMT_L1P2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
break;
|
|
case CCMFMT_L1P2I3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
else if (param_idx == 3)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1PP2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
break;
|
|
case CCMFMT_L1VV2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_L1L2:
|
|
if (param_idx == 1 || param_idx == 2)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_L1L2L3:
|
|
if (param_idx >= 1 && param_idx <= 3)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_LL1:
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_L1R2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_REGIONTAG;
|
|
break;
|
|
case CCMFMT_L1I2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2L3:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2LL3:
|
|
if (param_idx == 2)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_L1I2I3L4:
|
|
if (param_idx == 1 || param_idx == 4)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx == 2 || param_idx == 3)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx >= 2 && param_idx <= 5)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5I6I7:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx >= 2 && param_idx <= 7)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1I2I3I4I5I6I7I8I9:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else if (param_idx >= 2 && param_idx <= 9)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_L1II2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
else
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_R1:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_REGIONTAG;
|
|
break;
|
|
case CCMFMT_R1VV2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_REGIONTAG;
|
|
else
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_I1:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1P2I3:
|
|
if (param_idx == 1 || param_idx == 3)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_PROCEDURE;
|
|
break;
|
|
case CCMFMT_I1V2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_I1V2V3:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else if (param_idx == 2 || param_idx == 3)
|
|
res = CCM_HITYPE_VARIABLE;
|
|
break;
|
|
case CCMFMT_I1L2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else if (param_idx == 2)
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_I1LL2:
|
|
if (param_idx == 1)
|
|
res = CCM_HITYPE_INTEGER;
|
|
else
|
|
res = CCM_HITYPE_LOOPTAG;
|
|
break;
|
|
case CCMFMT_I1I2I3I4:
|
|
if (param_idx >= 1 && param_idx <= 4)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1I2I3I4I5I6:
|
|
if (param_idx >= 1 && param_idx <= 6)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_I1I2I3I4I5I6I7I8:
|
|
if (param_idx >= 1 && param_idx <= 8)
|
|
res = CCM_HITYPE_INTEGER;
|
|
break;
|
|
case CCMFMT_LAST:
|
|
default:
|
|
/* programming failure */
|
|
/* if(1) is hack to get around warning from C++ compiler */
|
|
if (1)
|
|
assert (0);
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
ccm_vis_init ()
|
|
{
|
|
int size, vindex;
|
|
static int done = 0;
|
|
if (done)
|
|
return;
|
|
done = 1;
|
|
size = ccm_vis_index ((COMPMSG_ID) (CCMV_BASIC << 8));
|
|
ccm_attrs = (Ccm_Attr_t *) calloc (size, sizeof (Ccm_Attr_t));
|
|
if (ccm_attrs == NULL)
|
|
exit (1);
|
|
vindex = ccm_vis_index (CCM_MODDATE);
|
|
ccm_attrs[vindex].vis = CCMV_VER | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MODDATE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Source file %s, last modified on date %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_COMPVER);
|
|
ccm_attrs[vindex].vis = CCMV_VER | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_COMPVER";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Component %s, version %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_COMPDATE);
|
|
ccm_attrs[vindex].vis = CCMV_VER | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_COMPDATE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Compilation date %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_COMPOPT);
|
|
ccm_attrs[vindex].vis = CCMV_VER | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_COMPOPT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Compilation options %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_ACOMPOPT);
|
|
ccm_attrs[vindex].vis = CCMV_VER | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_ACOMPOPT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Actual Compilation options %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_VAR_ALIAS);
|
|
ccm_attrs[vindex].vis = CCMV_WARN | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_VAR_ALIAS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variable %s aliased to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1V2;
|
|
|
|
vindex = ccm_vis_index (CCM_FBIRDIFF);
|
|
ccm_attrs[vindex].vis = CCMV_WARN | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_FBIRDIFF";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Profile feedback data inconsistent with"
|
|
" intermediate representation file; check compiler"
|
|
" version, flags and source file");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_OPTRED_SWAP);
|
|
ccm_attrs[vindex].vis = CCMV_WARN | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_OPTRED_SWAP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Optimization level for %s reduced from %d to"
|
|
" %d due to insufficient swap space");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_OPTRED_CPLX);
|
|
ccm_attrs[vindex].vis = CCMV_WARN | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_OPTRED_CPLX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Optimization level for %s reduced from %d to"
|
|
" %d due to program complexity");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_UNKNOWN);
|
|
ccm_attrs[vindex].vis = CCMV_WARN | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNKNOWN";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Unexpected compiler comment %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_CALL);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_CALL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it contains a"
|
|
" call to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_SER);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PAR_SER";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Both serial and parallel versions generated for"
|
|
" loop below");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_SER_VER);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PAR_SER_VER";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Both serial and parallel versions generated for"
|
|
" loop below; with parallel version used if %s,"
|
|
" serial otherwise");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_DRECTV);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PAR_DRECTV";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below parallelized by explicit user"
|
|
" directive");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_APAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_APAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below autoparallelized");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_AUTOPAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_AUTOPAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below autoparallelized; equivalent"
|
|
" explict directive is %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_DD);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_DD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below could not be parallelized because of a"
|
|
" data dependency on %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_DDA);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_DDA";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below could not be parallelized because of a"
|
|
" data dependency or aliasing of %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_ANONDD);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_ANONDD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below could not be parallelized because of"
|
|
" an anonymous data dependency");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_ANONDDA);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_ANONDDA";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below could not be parallelized because of"
|
|
" an anonymous data dependency or aliasing");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_WORK);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PAR_WORK";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below parallelized, but might not contain"
|
|
" enough work to be efficiently run in parallel");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_EXIT);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_EXIT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it contains"
|
|
" multiple exit points");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_STRNG);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_STRNG";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it contains a"
|
|
" strange flow of control");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_IO);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_IO";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it contains"
|
|
" I/O or other MT-unsafe calls");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_BODY_NAME);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PAR_BODY_NAME";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Parallel loop-body code is in function %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NLOOPIDX);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NLOOPIDX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because loop index"
|
|
" not found");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_DRECTV);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_DRECTV";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because of explicit"
|
|
" user directive");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NOTPROFIT);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NOTPROFIT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it was not"
|
|
" profitable to do so");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NEST);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NEST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it was"
|
|
" nested in a parallel loop");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NOAUTO);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NOAUTO";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because"
|
|
" autoparallelization is not enabled");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_PR_L_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PR_L_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Private variables in loop below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_SH_L_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_SH_L_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Shared variables in loop below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_TP_L_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_TP_L_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Threadprivate variables in loop below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_RV_L_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_RV_L_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Reduction variables in loop below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_IM_L_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IM_L_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Implicit variables in loop below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_PR_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PR_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Private variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_SH_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_SH_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Shared variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_TP_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_TP_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Threadprivate variables in OpenMP construct"
|
|
" below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_RV_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_RV_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Reduction variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_IM_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IM_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Implicit variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_IN_OMP);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_IN_OMP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below not parallelized because it is inside"
|
|
" an OpenMP region");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_FP_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_FP_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Firstprivate variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_LP_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LP_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Lastprivate variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_CP_O_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_CP_O_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Copyprivate variables in OpenMP construct below:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_PR_OAS_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PR_OAS_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as PRIVATE in OpenMP"
|
|
" construct below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_SH_OAS_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_SH_OAS_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as SHARED in OpenMP"
|
|
" construct below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_FP_OAS_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_FP_OAS_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as FIRSTPRIVATE in OpenMP"
|
|
" construct below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_LP_OAS_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LP_OAS_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as LASTPRIVATE in OpenMP"
|
|
" construct below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_RV_OAS_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_RV_OAS_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as REDUCTION in OpenMP"
|
|
" construct below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_FAIL_OAS_VAR);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_WARN | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_FAIL_OAS_VAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables cannot be autoscoped in OpenMP"
|
|
" construct below: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_VV1;
|
|
|
|
vindex = ccm_vis_index (CCM_SERIALIZE_OAS);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_WARN | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_SERIALIZE_OAS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"OpenMP parallel region below is serialized"
|
|
" because autoscoping has failed");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_CALL_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_CALL_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it contains calls"
|
|
" to: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1PP2;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_DRECTV_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PAR_DRECTV_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s parallelized by explicit user directive");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_APAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_APAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s autoparallelized");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_AUTOPAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_AUTOPAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s autoparallelized; equivalent"
|
|
" explict directive is %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_DD_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_DD_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be parallelized because of"
|
|
" data dependences on: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_DDA_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_DDA_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be parallelized because of a"
|
|
" data dependence or aliasing of: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_ANONDD_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_ANONDD_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be parallelized because of an"
|
|
" anonymous data dependence");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_ANONDDA_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_ANONDDA_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be parallelized because of an"
|
|
" anonymous data dependence or aliasing");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_WORK_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PAR_WORK_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s parallelized, but might not contain"
|
|
" enough work to run efficiently in parallel");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_EXIT_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_EXIT_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it contains"
|
|
" multiple exit points");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_STRANGE_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_STRANGE_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it contains a"
|
|
" strange flow of control");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_IO_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_IO_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it contains"
|
|
" I/O or other MT-unsafe calls");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_PAR_BODY_NAME_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP;
|
|
ccm_attrs[vindex].name = "CCM_PAR_BODY_NAME_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s parallel loop-body code placed in"
|
|
" function %s along with %d inner loops");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1P2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NLOOPIDX_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NLOOPIDX_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because loop index not"
|
|
" found");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_DRECTV_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_DRECTV_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because of explicit"
|
|
" user directive");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NOTPROFIT_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NOTPROFIT_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it was not"
|
|
" profitable to do so");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NEST_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NEST_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it was"
|
|
" nested within a parallel loop");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_NOAUTO_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_NOAUTO_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because"
|
|
" autoparallelization is not enabled");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_PR_L_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PR_L_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Private variables in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_SH_L_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_SH_L_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Shared variables in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_TP_L_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_TP_L_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Threadprivate variables in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_RV_L_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_RV_L_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Reduction variables of operator %s in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1L2VV3;
|
|
|
|
vindex = ccm_vis_index (CCM_IM_L_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IM_L_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Implicit variables in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_PR_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PR_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Private variables in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_SH_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_SH_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Shared variables in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_TP_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_TP_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Threadprivate variables in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_RV_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_RV_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Reduction variables of operator %s in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1R2VV3;
|
|
|
|
vindex = ccm_vis_index (CCM_IM_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IM_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Implicit variables in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_UNPAR_IN_OMP_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNPAR_IN_OMP_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s not parallelized because it is inside"
|
|
" OpenMP region %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1R2;
|
|
|
|
vindex = ccm_vis_index (CCM_FP_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_FP_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Firstprivate variables in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_LP_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LP_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Lastprivate variables in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_CP_O_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_CP_O_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Copyprivate variables in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_PR_OAS_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PR_OAS_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as PRIVATE in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_SH_OAS_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_SH_OAS_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as SHARED in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_FP_OAS_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_FP_OAS_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as FIRSTPRIVATE in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_LP_OAS_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LP_OAS_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as LASTPRIVATE in %s:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_RV_OAS_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_RV_OAS_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables autoscoped as REDUCTION of operator"
|
|
" %s in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1R2VV3;
|
|
|
|
vindex = ccm_vis_index (CCM_FAIL_OAS_VAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_WARN;
|
|
ccm_attrs[vindex].name = "CCM_FAIL_OAS_VAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variables treated as shared because they cannot"
|
|
" be autoscoped in %s: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1VV2;
|
|
|
|
vindex = ccm_vis_index (CCM_SERIALIZE_OAS_2);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC | CCMV_WARN;
|
|
ccm_attrs[vindex].name = "CCM_SERIALIZE_OAS_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s will be executed by a single thread because"
|
|
" autoscoping for some variables was not successful");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1;
|
|
|
|
vindex = ccm_vis_index (CCM_QPERMVEC);
|
|
ccm_attrs[vindex].vis = CCMV_QUERY | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_QPERMVEC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Is %s a permutation vector during execution of"
|
|
" %s?");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1L2;
|
|
|
|
vindex = ccm_vis_index (CCM_QEXPR);
|
|
ccm_attrs[vindex].vis = CCMV_QUERY | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_QEXPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Is expression %s true for %s?");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1L2;
|
|
|
|
vindex = ccm_vis_index (CCM_QSAFECALL);
|
|
ccm_attrs[vindex].vis = CCMV_QUERY | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_QSAFECALL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Is subroutine %s MP-safe as used in %s?");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1L2;
|
|
|
|
vindex = ccm_vis_index (CCM_LCOST);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LCOST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below estimated to cost %d cycles per"
|
|
" iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_UNROLL);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_UNROLL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below unrolled %d times");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_IMIX);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IMIX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below has %d loads, %d stores,"
|
|
" %d prefetches, %d FPadds, %d FPmuls, and"
|
|
" %d FPdivs per iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1I2I3I4I5I6;
|
|
|
|
vindex = ccm_vis_index (CCM_SPILLS);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_UNIMPL | CCMV_WANT | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_SPILLS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below required %d integer register spills,"
|
|
" %d FP register spills, and used"
|
|
" %d integer registers and %d FP registers");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1I2I3I4;
|
|
|
|
vindex = ccm_vis_index (CCM_LFISSION);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LFISSION";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below fissioned into %d loops");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_LPEEL);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LPEEL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below had iterations peeled off for better"
|
|
" unrolling and/or parallelization");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_LBLOCKED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LBLOCKED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below blocked by %d for improved cache"
|
|
" performance");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_LTILED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LTILED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below tiled for better performance");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_LUNRJAM);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LUNRJAM";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below unrolled and jammed");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_LWHILE2DO);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LWHILE2DO";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Bounds test for loop below moved to top of loop");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_L2CALL);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_L2CALL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below replaced by a call to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_LDEAD);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LDEAD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below deleted as dead code");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_LINTRCHNG);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LINTRCHNG";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below interchanged with loop on line %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_FUSEDTO);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_FUSEDTO";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below fused with loop on line %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_FUSEDFROM);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_FUSEDFROM";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop from line %d fused with loop below");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_VECINTRNSC);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_VECINTRNSC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below transformed to use calls to vector"
|
|
" intrinsic %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_PP1;
|
|
|
|
vindex = ccm_vis_index (CCM_LSTRIPMINE);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LSTRIPMINE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below strip-mined");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_LNEST2LOOPS);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LNEST2LOOPS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below collapsed with loop on line %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_LREVERSE);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LREVERSE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below has had its iteration direction"
|
|
" reversed");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_IMIX2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IMIX2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below has %d loads, %d stores,"
|
|
" %d prefetches, %d FPadds, %d FPmuls,"
|
|
" %d FPdivs, %d FPsubs, and %d FPsqrts per"
|
|
" iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1I2I3I4I5I6I7I8;
|
|
|
|
vindex = ccm_vis_index (CCM_LUNRFULL);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_LUNRFULL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below fully unrolled");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_ELIM_NOAMORTINST);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_ELIM_NOAMORTINST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below was eliminated as it contains no"
|
|
" non-amortizable instructions");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_COMP_DALIGN);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_COMP_DALIGN";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Performance of loop below could be improved"
|
|
" by compiling with -dalign");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_INTIMIX);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_INTIMIX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below has %d int-loads, %d int-stores,"
|
|
" %d alu-ops, %d muls, %d int-divs and"
|
|
" %d shifts per iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1I2I3I4I5I6;
|
|
|
|
vindex = ccm_vis_index (CCM_LMULTI_VERSION);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LMULTI_VERSION";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s multi-versioned. Specialized version"
|
|
" is %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1L2;
|
|
|
|
vindex = ccm_vis_index (CCM_LCOST_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LCOST_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s estimated to cost %d cycles per iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_UNROLL_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_UNROLL_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s unrolled %d times");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_IMIX_B);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_IMIX_B";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s has %d loads, %d stores,"
|
|
" %d prefetches, %d FPadds, %d FPmuls, and"
|
|
" %d FPdivs per iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2I3I4I5I6I7;
|
|
|
|
vindex = ccm_vis_index (CCM_SPILLS_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_SPILLS_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s required %d integer register spills,"
|
|
" %d FP register spills, and used"
|
|
" %d integer registers and %d FP registers");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2I3I4I5;
|
|
|
|
vindex = ccm_vis_index (CCM_LFISSION_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LFISSION_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s fissioned into %d loops, generating:"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2LL3;
|
|
|
|
vindex = ccm_vis_index (CCM_LFISSION_FRAG);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LFISSION_FRAG";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s contains code from lines: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1II2;
|
|
|
|
vindex = ccm_vis_index (CCM_LPEEL_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LPEEL_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s had iterations peeled off for better"
|
|
" unrolling and/or parallelization");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_LBLOCKED_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LBLOCKED_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s blocked by %d for improved memory"
|
|
" hierarchy performance, new inner loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LOUTER_UNROLL);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LOUTER_UNROLL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s is outer-unrolled %d times as part"
|
|
" of unroll and jam");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_LJAMMED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LJAMMED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"All %d copies of %s are fused together"
|
|
" as part of unroll and jam");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1L2;
|
|
|
|
vindex = ccm_vis_index (CCM_LWHILE2DO_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LWHILE2DO_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Bounds test for %s moved to top of loop");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_L2CALL_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_L2CALL_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s replaced by a call to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1P2;
|
|
|
|
vindex = ccm_vis_index (CCM_LDEAD_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LDEAD_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s deleted as dead code");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_LINTRCHNG_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LINTRCHNG_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s interchanged with %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1L2;
|
|
|
|
vindex = ccm_vis_index (CCM_LINTRCHNG_ORDER);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LINTRCHNG_ORDER";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"For loop nest below, the final order of loops"
|
|
" after interchanging and subsequent"
|
|
" transformations is: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_LL1;
|
|
|
|
vindex = ccm_vis_index (CCM_FUSED_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_FUSED_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s fused with %s, new loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1L2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_VECINTRNSC_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_VECINTRNSC_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s transformed to use calls to vector"
|
|
" intrinsics: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1PP2;
|
|
|
|
vindex = ccm_vis_index (CCM_LSTRIPMINE_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LSTRIPMINE_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s strip-mined by %d, new inner loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LNEST2LOOPS_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LNEST2LOOPS_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s collapsed with %s, new loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1L2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LREVERSE_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LREVERSE_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s has had its iteration direction reversed");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_IMIX2_B);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_IMIX2_B";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s has %d loads, %d stores,"
|
|
" %d prefetches, %d FPadds, %d FPmuls,"
|
|
" %d FPdivs, %d FPsubs, and %d FPsqrts per"
|
|
" iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2I3I4I5I6I7I8I9;
|
|
|
|
vindex = ccm_vis_index (CCM_LUNRFULL_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LUNRFULL_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s fully unrolled");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_ELIM_NOAMORTINST_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_ELIM_NOAMORTINST_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s was eliminated as it contains no"
|
|
" non-amortizable instructions");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_COMP_DALIGN_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_COMP_DALIGN_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Performance of %s could be improved by"
|
|
" compiling with -dalign");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_INTIMIX_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INTIMIX_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s has %d int-loads, %d int-stores,"
|
|
" %d alu-ops, %d muls, %d int-divs and"
|
|
" %d shifts per iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2I3I4I5I6I7;
|
|
|
|
vindex = ccm_vis_index (CCM_OMP_REGION);
|
|
ccm_attrs[vindex].vis = CCMV_PAR | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_OMP_REGION";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Source OpenMP region below has tag %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_R1;
|
|
|
|
vindex = ccm_vis_index (CCM_LMICROVECTORIZE);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LMICROVECTORIZE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s is micro-vectorized");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_LMULTI_VERSION_2);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LMULTI_VERSION_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s multi-versioned for %s."
|
|
" Specialized version is %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1S2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LCLONED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LCLONED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s cloned for %s. Clone is %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1S2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LUNSWITCHED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LUNSWITCHED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s is unswitched. New loops"
|
|
" are %s and %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1L2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LRESWITCHED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LRESWITCHED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loops %s and %s and their surrounding"
|
|
" conditional code have been merged to"
|
|
" form loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1L2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_LSKEWBLOCKED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LSKEWBLOCKED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s skew-blocked by %d with slope"
|
|
" %d for improved memory hierarchy"
|
|
" performance, new inner loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2I3L4;
|
|
|
|
vindex = ccm_vis_index (CCM_IVSUB);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_IVSUB";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Induction variable substitution performed on %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_ONEITER_REPLACED);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_ONEITER_REPLACED";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s determined to have a trip count of 1;"
|
|
" converted to straight-line code");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_IMIX3_B);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_IMIX3_B";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s has %d loads, %d stores,"
|
|
" %d prefetches, %d FPadds, %d FPmuls,"
|
|
" %d FPmuladds, %d FPdivs, and %d FPsqrts per"
|
|
" iteration");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2I3I4I5I6I7I8I9;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPELINE);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PIPELINE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below pipelined");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPESTATS);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PIPESTATS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below scheduled with steady-state cycle"
|
|
" count = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_CALL);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_CALL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" calls");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INTCC);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INTCC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it sets"
|
|
" multiple integer condition codes.");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_MBAR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_MBAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains a"
|
|
" memory barrier instruction");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_MNMX);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_MNMX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" a minimum or a maximum operation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_U2FLT);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_U2FLT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" an unsigned to float conversion");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_GOT);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_GOT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it sets the"
|
|
" Global Offset Table pointer");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_IDIV);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_IDIV";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" an integer divide");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_PRFTCH);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_PRFTCH";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" a prefetch operation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_EXIT);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_EXIT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" an exit operation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_REG);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_REG";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it contains"
|
|
" instructions that set the %%gsr or %%fsr register");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_UNS);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_UNS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it has an"
|
|
" unsigned loop counter");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_UNSUIT);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_UNSUIT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop was unsuitable for pipelining");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INTRINSIC);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INTRINSIC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined because it has an"
|
|
" intrinsic call to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_BIG);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_BIG";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined as it is too big");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INVINTPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INVINTPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined as it contains too"
|
|
" many loop invariant integers = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INVFLTPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INVFLTPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined as it contains too"
|
|
" many loop invariant floats = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INVDBLPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INVDBLPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined as it contains too"
|
|
" many loop invariant doubles = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPE_SCHEDAFIPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PIPE_SCHEDAFIPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below was adversely affected by high"
|
|
" integer register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPE_SCHEDAFDPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PIPE_SCHEDAFDPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below was adversely affected by high"
|
|
" double register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPE_SCHEDAFFPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_PIPE_SCHEDAFFPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop below was adversely affected by high"
|
|
" float register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INTPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INTPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined due to high"
|
|
" integer register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_DBLPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_DBLPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined due to high"
|
|
" double register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_FLTPR);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_FLTPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop could not be pipelined due to high"
|
|
" float register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPELINE_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PIPELINE_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s pipelined");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPESTATS_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PIPESTATS_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s scheduled with steady-state cycle"
|
|
" count = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_CALL_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_CALL_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" calls");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INTCC_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INTCC_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it sets"
|
|
" multiple integer condition codes.");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_MBAR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_MBAR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" a memory barrier instruction");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_MNMX_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_MNMX_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" a minimum or a maximum operation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_U2FLT_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_U2FLT_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" an unsigned to float conversion");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_GOT_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_GOT_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it sets the"
|
|
" Global Offset Table pointer");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_IDIV_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_IDIV_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" an integer divide");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_PRFTCH_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_PRFTCH_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" a prefetch operation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_EXIT_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_EXIT_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" an exit operation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_REG_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_REG_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" instructions that set the %%gsr or %%fsr register");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_UNS_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_UNS_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it has an"
|
|
" unsigned loop counter");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_UNSUIT_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_UNSUIT_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s is unsuitable for pipelining");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INTRINSIC_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INTRINSIC_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined because it contains"
|
|
" a call to intrinsic %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1P2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_BIG_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_BIG_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined as it is too big");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INVINTPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INVINTPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined as it contains too"
|
|
" many loop invariant integers = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INVFLTPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INVFLTPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined as it contains too"
|
|
" many loop invariant floats = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INVDBLPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INVDBLPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined as it contains too"
|
|
" many loop invariant doubles = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPE_SCHEDAFIPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PIPE_SCHEDAFIPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s was adversely affected by high"
|
|
" integer register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPE_SCHEDAFDPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PIPE_SCHEDAFDPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s was adversely affected by high"
|
|
" double register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_PIPE_SCHEDAFFPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PIPE_SCHEDAFFPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s was adversely affected by high"
|
|
" float register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_INTPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_INTPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined due to high"
|
|
" integer register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_DBLPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_DBLPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined due to high"
|
|
" double register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NOPIPE_FLTPR_2);
|
|
ccm_attrs[vindex].vis = CCMV_PIPE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NOPIPE_FLTPR_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"%s could not be pipelined due to high"
|
|
" float register pressure = %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_INLINE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from source file %s into"
|
|
" the code for the following line");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE2);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_INLINE2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from source file %s into"
|
|
" inline copy of function %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2P3;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE_TMPLT);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INLINE_TMPLT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from template file %s"
|
|
" into the code for the following line");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE_TMPLT2);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INLINE_TMPLT2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from template file %s"
|
|
" into inline copy of function %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2P3;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE_OUT_COPY);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INLINE_OUT_COPY";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Out-of-line copy of inlined function %s from"
|
|
" source file %s generated");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_REC);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_REC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Recursive function %s inlined only up to"
|
|
" depth %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_NEST);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_NEST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because inlining is"
|
|
" already nested too deeply");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CMPLX);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CMPLX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains"
|
|
" too many operations");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_FB);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_FB";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because the"
|
|
" profile-feedback execution count is too low");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_PAR);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_PAR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains"
|
|
" explicit parallel pragmas");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_OPT);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_OPT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is"
|
|
" compiled with optimization level <= 2");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_USR);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_USR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because either command"
|
|
" line option or source code pragma prohibited it,"
|
|
" or it's not safe to inline it");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_AUTO);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_AUTO";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because doing so"
|
|
" would make automatic storage for %s too large");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1P2;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALLS);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALLS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains"
|
|
" too many calls");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_ACTUAL);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_ACTUAL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it has more"
|
|
" actual parameters than formal parameters");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_FORMAL);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_FORMAL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it has more"
|
|
" formal parameters than actual parameters");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_TYPE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_TYPE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because formal"
|
|
" argument type does not match actual type");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_ATYPE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_ATYPE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because array formal"
|
|
" argument does not match reshaped array actual"
|
|
" argument type");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_RETTYPE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_RETTYPE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because return type"
|
|
" does not match");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_EXCPT);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_EXCPT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it"
|
|
" guarded by an exception handler");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_UNSAFE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_UNSAFE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it might be"
|
|
" unsafe (call alloca(), etc)");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_ALIAS);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_ALIAS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because inlining it"
|
|
" will make the alias analysis in the calling"
|
|
" function more conservative");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_FEMARK);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_FEMARK";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains"
|
|
" setjmp/longjmp, or indirect goto, etc");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_RAREX);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_RAREX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is known"
|
|
" to be rarely executed");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_CLONING);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_CLONING";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s from source file %s cloned,"
|
|
" creating cloned function %s; constant"
|
|
" parameters propagated to clone");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2P3;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE_B);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INLINE_B";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from source file %s into"
|
|
" the code for the following line. %d loops"
|
|
" inlined");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE2_B);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INLINE2_B";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from source file %s into"
|
|
" inline copy of function %s. %d loops inlined");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2P3I4;
|
|
|
|
vindex = ccm_vis_index (CCM_INLINE_LOOP);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_LOOP | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_INLINE_LOOP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Loop in function %s, line %d has"
|
|
" tag %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2L3;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_MULTIENTRY);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_MULTIENTRY";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it"
|
|
" contains an ENTRY statement");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_VARARGS);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_VARARGS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because variable"
|
|
" argument routines cannot be inlined");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_UNSEEN_BODY);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_UNSEEN_BODY";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because the compiler"
|
|
" has not seen the body of the function. Use"
|
|
" -xcrossfile or -xipo in order to inline it");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_UPLEVEL);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_UPLEVEL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is a"
|
|
" nested routine containing references to"
|
|
" variables defined in an outer function");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CMDLINE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CMDLINE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because either"
|
|
" -xinline or source code pragma prohibited it");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_CMPLX);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_CMPLX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because of the"
|
|
" complexity of the calling routine");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_LANG_MISMATCH);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_LANG_MISMATCH";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because it is in"
|
|
" a different language");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_RTN_WEAK);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_RTN_WEAK";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it"
|
|
" is marked weak");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_WEAKFILE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_WEAKFILE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because it is"
|
|
" in a different file and it contains a"
|
|
" call to a weak routine");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_TRYCATCH);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_TRYCATCH";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because it is"
|
|
" in a different file and contains an"
|
|
" explicit try/catch");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_REGP);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_REGP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because it would"
|
|
" cause excessive register pressure");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_RTN_REGP);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_RTN_REGP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it would"
|
|
" cause excessive register pressure");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_XPENSV);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_XPENSV";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because analysis"
|
|
" exceeds the compilation time limit");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_READONLYIR);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_READONLYIR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is in a file"
|
|
" specified as read-only by -xipo_archive=readonly"
|
|
" and it contains calls to static functions");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_THUNK);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_THUNK";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because it is in a"
|
|
" compiler-generated function that does not"
|
|
" permit inlining");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CALL_XTARGETS);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CALL_XTARGETS";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Indirect callsite has too many targets;"
|
|
" callsite marked do not inline");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_SELFTAIL_RECURSIVE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_SELFTAIL_RECURSIVE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because"
|
|
" of a recursive tail-call to itself");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_PRAGMA);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_PRAGMA";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains"
|
|
" explicit parallel or alias pragmas");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CMPLX2);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CMPLX2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains too"
|
|
" many operations. Increase max_inst_hard in order"
|
|
" to inline it: -xinline_param=max_inst_hard:n");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_RARE);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_RARE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because the call"
|
|
" is rarely executed");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_PAR2);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_PAR2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is called"
|
|
" within a region guarded by an explicit"
|
|
" parallel pragmas");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_G_LIMIT);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_G_LIMIT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s 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_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_L_LIMIT);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_L_LIMIT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s 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_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_REC2);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_REC2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Recursive function %s is inlined only up to"
|
|
" %d levels and up to %d 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_attrs[vindex].fmt = CCMFMT_P1I2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_FB2);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_FB2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s 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_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_CS_CMPLX);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_CS_CMPLX";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s 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_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_R_EXCPT);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_R_EXCPT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it contains"
|
|
" an exception handler");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_ASM);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_ASM";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because"
|
|
" it contains asm statements");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_R_READONLYIR);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_R_READONLYIR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is in a file"
|
|
" specified as read-only by -xipo_archive=readonly"
|
|
" and it is a static function");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_C_READONLYIR);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_C_READONLYIR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s not inlined because the calling"
|
|
" function is in a file specified as read-only"
|
|
" by -xipo_archive=readonly");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NINLINE_NEVERRETURN);
|
|
ccm_attrs[vindex].vis = CCMV_INLINE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NINLINE_NEVERRETURN";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it"
|
|
" never returns");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_MPREFETCH);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MPREFETCH";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Prefetch of %s inserted");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_MPREFETCH_LD);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MPREFETCH_LD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Prefetch of %s inserted for load at %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1X2;
|
|
|
|
vindex = ccm_vis_index (CCM_MPREFETCH_ST);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MPREFETCH_ST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Prefetch of %s inserted for store at %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1X2;
|
|
|
|
vindex = ccm_vis_index (CCM_MPREFETCH_FB);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MPREFETCH_FB";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Prefetch of %s inserted based on feedback data");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_MPREFETCH_FB_LD);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MPREFETCH_FB_LD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Prefetch of %s inserted for load at %s based"
|
|
" on feedback data");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1X2;
|
|
|
|
vindex = ccm_vis_index (CCM_MPREFETCH_FB_ST);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MPREFETCH_FB_ST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Prefetch of %s inserted for store at %s based"
|
|
" on feedback data");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1X2;
|
|
|
|
vindex = ccm_vis_index (CCM_MLOAD);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MLOAD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Load below refers to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_MSTORE);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MSTORE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Store below refers to %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_MLOAD_P);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MLOAD_P";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Load below refers to %s, and was prefetched"
|
|
" at %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1X2;
|
|
|
|
vindex = ccm_vis_index (CCM_MSTORE_P);
|
|
ccm_attrs[vindex].vis = CCMV_MEMOPS | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MSTORE_P";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Store below refers to %s, and was prefetched"
|
|
" at %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1X2;
|
|
|
|
vindex = ccm_vis_index (CCM_COPYIN);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_COPYIN";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Parameter %d caused a copyin in the following"
|
|
" call");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_COPYOUT);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_COPYOUT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Parameter %d caused a copyout in the following"
|
|
" call");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_COPYINOUT);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_COPYINOUT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Parameter %d caused both a copyin and copyout"
|
|
" in the following call");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_PADDING);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_PADDING";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Padding of %d bytes inserted before"
|
|
" array %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1V2;
|
|
|
|
vindex = ccm_vis_index (CCM_PADCOMMON);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_PADCOMMON";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Padding of %d bytes inserted before"
|
|
" array %s in common block %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1V2V3;
|
|
|
|
vindex = ccm_vis_index (CCM_ALIGN_EQ);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_ALIGN_EQ";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Variable/array %s can not be double-aligned,"
|
|
" because it is equivalenced");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_ALIGN_PERF);
|
|
ccm_attrs[vindex].vis = CCMV_FE;
|
|
ccm_attrs[vindex].name = "CCM_ALIGN_PERF";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Alignment of variables in common block may cause"
|
|
" performance degradation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_ALIGN_STRUCT);
|
|
ccm_attrs[vindex].vis = CCMV_FE;
|
|
ccm_attrs[vindex].name = "CCM_ALIGN_STRUCT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Alignment of component %s in numeric sequence"
|
|
" structure %s may cause performance degradation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_TMP_COPY);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TMP_COPY";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %s copied to a temporary");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_TMP_COPYM);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TMP_COPYM";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %s might be copied to a temporary;"
|
|
" runtime decision made");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_PROC_MISMATCH);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_PROC_MISMATCH";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %d to subprogram %s differs from"
|
|
" reference on line %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1P2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_PROC_MISMATCH2);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_PROC_MISMATCH2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Scalar argument %d to subprogram %s is"
|
|
" referred to as an array on line %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1P2I3;
|
|
|
|
vindex = ccm_vis_index (CCM_PROC_MISMATCH3);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_PROC_MISMATCH3";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Return type/rank from subprogram %s differs"
|
|
" from return on line %d");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_DO_EXPR);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_DO_EXPR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"DO statement bounds lead to no executions of the"
|
|
" loop");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_AUTO_BND);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_AUTO_BND";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"The bounds for automatic variable %s are not"
|
|
" available at all entry points; zero-length"
|
|
" variable might be allocated");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_LIT_PAD);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_LIT_PAD";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"The character string literal %s padded"
|
|
" to the length specified for the dummy argument");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_ARRAY_LOOP);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_ARRAY_LOOP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Array statement below generated a loop");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_ARRAY_LOOPNEST);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_OBS;
|
|
ccm_attrs[vindex].name = "CCM_ARRAY_LOOPNEST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Array statement below generated %d nested loops");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_ALIGN_PERF2);
|
|
ccm_attrs[vindex].vis = CCMV_FE;
|
|
ccm_attrs[vindex].name = "CCM_ALIGN_PERF2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Alignment of variable %s in common block %s"
|
|
" may cause a performance degradation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1V2;
|
|
|
|
vindex = ccm_vis_index (CCM_ALIGN_PERF3);
|
|
ccm_attrs[vindex].vis = CCMV_FE;
|
|
ccm_attrs[vindex].name = "CCM_ALIGN_PERF3";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Alignment of variable %s in blank common may"
|
|
" cause a performance degradation");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_IO_LOOP_ARRAY);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_IO_LOOP_ARRAY";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"I/O implied do item below generated an array"
|
|
" section");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_TMPCONST);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_TMPCONST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Implicit invocation of class %s constructor for"
|
|
" temporary");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_TMPDEST);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_TMPDEST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Implicit invocation of class %s destructor for"
|
|
" temporary");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_DBL_CONST);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_DBL_CONST";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Double constant %s used in float expression");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_MINLINE);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MINLINE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s inlined from source file %s by"
|
|
" front-end");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_MINLINE2);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MINLINE2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s from source file %s inlined into"
|
|
" inline copy of method %s by front-end");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2P3;
|
|
|
|
vindex = ccm_vis_index (CCM_MINLINE3);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MINLINE3";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it uses keyword"
|
|
" %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1S2;
|
|
|
|
vindex = ccm_vis_index (CCM_MINLINE4);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC | CCMV_UNIMPL;
|
|
ccm_attrs[vindex].name = "CCM_MINLINE4";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s not inlined because it is too"
|
|
" complex");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_TMP_COPYOUT);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TMP_COPYOUT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %s copied from a temporary");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_TMP_COPYOUTM);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TMP_COPYOUTM";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %s might be copied from a temporary;"
|
|
" runtime decision made");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_TMP_COPYINOUT);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TMP_COPYINOUT";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %s copied in and out of a temporary");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_TMP_COPYINOUTM);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TMP_COPYINOUTM";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Argument %s might be copied in and out of"
|
|
" a temporary; runtime decision made");
|
|
ccm_attrs[vindex].fmt = CCMFMT_V1;
|
|
|
|
vindex = ccm_vis_index (CCM_ARRAY_LOOP_2);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_ARRAY_LOOP_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Array statement below generated loop %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_ARRAY_LOOPNEST_2);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_ARRAY_LOOPNEST_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Array statement below generated %d nested"
|
|
" loops: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1LL2;
|
|
|
|
vindex = ccm_vis_index (CCM_IO_LOOP_ARRAY_2);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_IO_LOOP_ARRAY_2";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"I/O implied do item below generated an array"
|
|
" section: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_USER_LOOP);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_USER_LOOP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Source loop below has tag %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_FOUND_LOOP);
|
|
ccm_attrs[vindex].vis = CCMV_FE | CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_FOUND_LOOP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Discovered loop below has tag %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_MFUNCTION_LOOP);
|
|
ccm_attrs[vindex].vis = CCMV_LOOP | CCMV_BASIC | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_MFUNCTION_LOOP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Copy in M-function of loop below has tag %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_L1;
|
|
|
|
vindex = ccm_vis_index (CCM_FSIMPLE);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_FSIMPLE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Transformations for fsimple=%d applied");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_STACK);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_STACK";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Function %s requires %d Mbytes of stack"
|
|
" storage");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2;
|
|
|
|
vindex = ccm_vis_index (CCM_TAILRECUR);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_TAILRECUR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Recursive tail call in %s optimized to jump to"
|
|
" entry point");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_TAILCALL);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC | CCMV_UNIMPL | CCMV_WANT;
|
|
ccm_attrs[vindex].name = "CCM_TAILCALL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to function %s was tail-call optimized");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_EXIT_OR_PSEUDO);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_EXIT_OR_PSEUDO";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains the pseudo instruction %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_UNARY_OPC);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_UNARY_OPC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains the instruction opcode %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_INT_LDD_ON_V9);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_INT_LDD_ON_V9";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains integer ldd instructions, which are"
|
|
" deprecated in the v9 architecture");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_LATE_INL_OPC);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_LATE_INL_OPC";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains the instruction opcode %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_IMM_OP);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_IMM_OP";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because the"
|
|
" relocation or immediate operand %s is not well"
|
|
" understood by the optimizer");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_STATELEAF);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_STATELEAF";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" references the state register %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_ASR_19);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_ASR_19";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because"
|
|
" %%asr19 is not supported in pre v8plus code");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_FSR_USE);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_FSR_USE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because"
|
|
" references to %%fsr can only be optimized when the"
|
|
" -iaopts flag is used");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_REGISTER);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_REGISTER";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" references the register %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_NO_RET_VAL);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_NO_RET_VAL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" does not return the value declared");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_DELAY);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_DELAY";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains a non nop delay slot");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_SCALL);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_SCALL";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" calls a function which returns a structure");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_CASE_POSITION);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_CASE_POSITION";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Case block below was placed at position %d"
|
|
" based on execution frequency");
|
|
ccm_attrs[vindex].fmt = CCMFMT_I1;
|
|
|
|
vindex = ccm_vis_index (CCM_CALL_WITH_CODE);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_CALL_WITH_CODE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Call to %s replaced with inline code. %d"
|
|
" loops created: %s");
|
|
ccm_attrs[vindex].fmt = CCMFMT_P1I2LL3;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_SP_ADDR);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_SP_ADDR";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains a %%sp+reg address");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_BAD_SP_USAGE);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_BAD_SP_USAGE";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" uses/defines the stack pointer in a non-load/store instruction");
|
|
ccm_attrs[vindex].fmt = CCMFMT_NONE;
|
|
|
|
vindex = ccm_vis_index (CCM_NI_MIXED_REG_TYPES);
|
|
ccm_attrs[vindex].vis = CCMV_CG | CCMV_BASIC;
|
|
ccm_attrs[vindex].name = "CCM_NI_MIXED_REG_TYPES";
|
|
ccm_attrs[vindex].msg = catgets (ccm_catd, 99, vindex,
|
|
"Template could not be early inlined because it"
|
|
" contains register %s used as both x-register and register pair");
|
|
ccm_attrs[vindex].fmt = CCMFMT_S1;
|
|
}
|