| /* Copyright (C) 2021-2023 Free Software Foundation, Inc. |
| Contributed by Oracle. |
| |
| This file is part of GNU Binutils. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, 51 Franklin Street - Fifth Floor, Boston, |
| MA 02110-1301, USA. */ |
| |
| #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"; |
|