gcc/f/target.h

   1 /* target.h -- Public #include File (module.h template V1.0)
   2    Copyright (C) 1995, 1996, 2002 Free Software Foundation, Inc.
   3    Contributed by James Craig Burley.
   4
   5 This file is part of GNU Fortran.
   6
   7 GNU Fortran is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Fortran is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Fortran; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21
  22    Owning Modules:
  23       target.c
  24
  25    Modifications:
  26 */
  27
  28 /* Allow multiple inclusion to work. */
  29
  30 #ifndef GCC_F_TARGET_H
  31 #define GCC_F_TARGET_H
  32
  33 #ifndef TREE_CODE
  34 #include "tree.h"
  35 #endif
  36
  37 /* Simple definitions and enumerations. */
  38
  39 #define FFETARGET_charactersizeNONE (-1)
  40 #ifndef FFETARGET_charactersizeMAXIMUM
  41 #define FFETARGET_charactersizeMAXIMUM 2147483647
  42 #endif
  43
  44 #ifndef FFETARGET_defaultIS_90
  45 #define FFETARGET_defaultIS_90 0
  46 #endif
  47 #ifndef FFETARGET_defaultIS_AUTOMATIC
  48 #define FFETARGET_defaultIS_AUTOMATIC 1
  49 #endif
  50 #ifndef FFETARGET_defaultIS_BACKSLASH
  51 #define FFETARGET_defaultIS_BACKSLASH 1
  52 #endif
  53 #ifndef FFETARGET_defaultIS_INIT_LOCAL_ZERO
  54 #define FFETARGET_defaultIS_INIT_LOCAL_ZERO 0
  55 #endif
  56 #ifndef FFETARGET_defaultIS_DOLLAR_OK
  57 #define FFETARGET_defaultIS_DOLLAR_OK 0
  58 #endif
  59 #ifndef FFETARGET_defaultIS_F2C
  60 #define FFETARGET_defaultIS_F2C 1
  61 #endif
  62 #ifndef FFETARGET_defaultIS_F2C_LIBRARY
  63 #define FFETARGET_defaultIS_F2C_LIBRARY 1
  64 #endif
  65 #ifndef FFETARGET_defaultIS_FREE_FORM
  66 #define FFETARGET_defaultIS_FREE_FORM 0
  67 #endif
  68 #ifndef FFETARGET_defaultIS_PEDANTIC
  69 #define FFETARGET_defaultIS_PEDANTIC 0
  70 #endif
  71 #ifndef FFETARGET_defaultCASE_INTRIN
  72 #define FFETARGET_defaultCASE_INTRIN FFE_caseLOWER
  73 #endif
  74 #ifndef FFETARGET_defaultCASE_MATCH
  75 #define FFETARGET_defaultCASE_MATCH FFE_caseLOWER
  76 #endif
  77 #ifndef FFETARGET_defaultCASE_SOURCE
  78 #define FFETARGET_defaultCASE_SOURCE FFE_caseLOWER
  79 #endif
  80 #ifndef FFETARGET_defaultCASE_SYMBOL
  81 #define FFETARGET_defaultCASE_SYMBOL FFE_caseNONE
  82 #endif
  83
  84 #ifndef FFETARGET_defaultFIXED_LINE_LENGTH
  85 #define FFETARGET_defaultFIXED_LINE_LENGTH 72
  86 #endif
  87
  88 /* 1 if external Fortran names ("FOO" in SUBROUTINE FOO, COMMON /FOO/,
  89    and even enforced/default-for-unnamed PROGRAM, blank-COMMON, and
  90    BLOCK DATA names, but not names of library functions implementing
  91    intrinsics or names of local/internal variables) should have an
  92    underscore appended (for compatibility with existing systems).  */
  93
  94 #ifndef FFETARGET_defaultEXTERNAL_UNDERSCORED
  95 #define FFETARGET_defaultEXTERNAL_UNDERSCORED 1
  96 #endif
  97
  98 /* 1 if external Fortran names with underscores already in them should
  99    have an extra underscore appended (in addition to the one they
 100    might already have appened if FFETARGET_defaultEXTERNAL_UNDERSCORED). */
 101
 102 #ifndef FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED
 103 #define FFETARGET_defaultUNDERSCORED_EXTERNAL_UNDERSCORED 1
 104 #endif
 105
 106 /* If FFETARGET_defaultEXTERNAL_UNDERSCORED is 0, the following definitions
 107    might also need to be overridden to make g77 objects compatible with
 108    f2c+gcc objects.  Although I don't think the unnamed BLOCK DATA one
 109    is an issue at all.  Of course, on some systems it isn't f2c
 110    compatibility that is the issue -- maybe compatibility with some
 111    other compiler(s).  I don't know what to recommend for systems where
 112    there is no existing Fortran compiler -- I suppose porting f2c and
 113    pretending it's the existing one is best for now.  */
 114
 115 /* 1 if the "FOO" in "PROGRAM FOO" should be overridden and a particular
 116    name imposed in place of it in the actual code (normally the case,
 117    because the library's main entry point on most systems calls the main
 118    function by a particular name).  Someday g77 might do the f2c trick
 119    of also outputting a "FOO" procedure that just calls the main procedure,
 120    but that'll wait until somebody shows why it is needed.  */
 121
 122 #ifndef FFETARGET_isENFORCED_MAIN
 123 #define FFETARGET_isENFORCED_MAIN 1
 124 #endif
 125
 126 /* The enforced name of the main program if ENFORCED_MAIN is 1.  */
 127
 128 #ifndef FFETARGET_nameENFORCED_MAIN_NAME
 129 #define FFETARGET_nameENFORCED_MAIN_NAME "MAIN__"
 130 #endif
 131
 132 /* The name used for an unnamed main program if ENFORCED_MAIN is 0.  */
 133
 134 #ifndef FFETARGET_nameUNNAMED_MAIN
 135 #define FFETARGET_nameUNNAMED_MAIN "MAIN__"
 136 #endif
 137
 138 /* The name used for an unnamed block data program.  */
 139
 140 #ifndef FFETARGET_nameUNNAMED_BLOCK_DATA
 141 #define FFETARGET_nameUNNAMED_BLOCK_DATA "_BLOCK_DATA__"
 142 #endif
 143
 144 /* The name used for blank common.  */
 145
 146 #ifndef FFETARGET_nameBLANK_COMMON
 147 #define FFETARGET_nameBLANK_COMMON "_BLNK__"
 148 #endif
 149
 150 #ifndef FFETARGET_integerSMALLEST_POSITIVE
 151 #define FFETARGET_integerSMALLEST_POSITIVE 0
 152 #endif
 153 #ifndef FFETARGET_integerLARGEST_POSITIVE
 154 #define FFETARGET_integerLARGEST_POSITIVE 2147483647
 155 #endif
 156 #ifndef FFETARGET_integerBIG_MAGICAL
 157 #define FFETARGET_integerBIG_MAGICAL 020000000000       /* 2147483648 */
 158 #endif
 159 #ifndef FFETARGET_integerALMOST_BIG_MAGICAL
 160 #define FFETARGET_integerALMOST_BIG_MAGICAL 214748364
 161 #endif
 162 #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_BINARY
 163 #define FFETARGET_integerALMOST_BIG_OVERFLOW_BINARY 0x80000000
 164 #endif
 165 #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_HEX
 166 #define FFETARGET_integerALMOST_BIG_OVERFLOW_HEX 0x10000000
 167 #endif
 168 #ifndef FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL
 169 #define FFETARGET_integerALMOST_BIG_OVERFLOW_OCTAL 0x20000000
 170 #endif
 171 #ifndef FFETARGET_integerFINISH_BIG_MAGICAL
 172 #define FFETARGET_integerFINISH_BIG_MAGICAL 8
 173 #endif
 174 #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_BINARY
 175 #define FFETARGET_integerFINISH_BIG_OVERFLOW_BINARY 0
 176 #endif
 177 #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_HEX
 178 #define FFETARGET_integerFINISH_BIG_OVERFLOW_HEX 0
 179 #endif
 180 #ifndef FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL
 181 #define FFETARGET_integerFINISH_BIG_OVERFLOW_OCTAL 0
 182 #endif
 183
 184 #ifndef FFETARGET_offsetNONE
 185 #define FFETARGET_offsetNONE 0  /* Not used by FFE, for backend if needed. */
 186 #endif
 187
 188 #define FFETARGET_okINTEGER1 1
 189 #define FFETARGET_okINTEGER2 1
 190 #define FFETARGET_okINTEGER3 1
 191 #define FFETARGET_okINTEGER4 1
 192 #define FFETARGET_okLOGICAL1 1
 193 #define FFETARGET_okLOGICAL2 1
 194 #define FFETARGET_okLOGICAL3 1
 195 #define FFETARGET_okLOGICAL4 1
 196 #define FFETARGET_okREAL1 1
 197 #define FFETARGET_okREAL2 1
 198 #define FFETARGET_okREAL3 0
 199 #define FFETARGET_okREALQUAD FFETARGET_okREAL3
 200 #define FFETARGET_okCOMPLEX1 1
 201 #define FFETARGET_okCOMPLEX2 1
 202 #define FFETARGET_okCOMPLEX3 0
 203 #define FFETARGET_okCOMPLEXDOUBLE FFETARGET_okCOMPLEX2
 204 #define FFETARGET_okCOMPLEXQUAD FFETARGET_okCOMPLEX3
 205 #define FFETARGET_okCHARACTER1 1
 206
 207 #define FFETARGET_f2cTYUNKNOWN 0
 208 #define FFETARGET_f2cTYADDR 1
 209 #define FFETARGET_f2cTYSHORT 2
 210 #define FFETARGET_f2cTYLONG 3
 211 #define FFETARGET_f2cTYREAL 4
 212 #define FFETARGET_f2cTYDREAL 5
 213 #define FFETARGET_f2cTYCOMPLEX 6
 214 #define FFETARGET_f2cTYDCOMPLEX 7
 215 #define FFETARGET_f2cTYLOGICAL 8
 216 #define FFETARGET_f2cTYCHAR 9
 217 #define FFETARGET_f2cTYSUBR 10
 218 #define FFETARGET_f2cTYINT1 11
 219 #define FFETARGET_f2cTYLOGICAL1 12
 220 #define FFETARGET_f2cTYLOGICAL2 13
 221 #define FFETARGET_f2cTYQUAD 14
 222
 223 #if (!defined(__alpha__) \
 224      && (!defined(__hppa__) || !defined(__LP64__)) \
 225      && (!defined(__ia64__) || !defined(__LP64__)) \
 226      && !defined(__MMIX__) \
 227      && (!defined (_ARCH_PPC) || !defined (__64BIT__)) \
 228      && !defined(__powerpc64__) \
 229      && !defined(__s390x__) \
 230      && (!defined(__sparc__) || (!defined(__sparcv9) && !defined(__arch64__)))\
 231      && !defined(__x86_64__))
 232 #define FFETARGET_32bit_longs
 233 #endif
 234
 235 /* Typedefs. */
 236
 237 typedef unsigned char ffetargetAlign;   /* ffetargetOffset for alignment. */
 238 #define ffetargetAlign_f ""
 239 typedef long ffetargetCharacterSize;
 240 #define ffetargetCharacterSize_f "l"
 241 typedef void (*ffetargetCopyfunc) (void *, void *, size_t);
 242 typedef ffetargetCharacterSize ffetargetHollerithSize;
 243 #define ffetargetHollerithSize_f "l"
 244 typedef long long ffetargetOffset;
 245 #define ffetargetOffset_f "ll"
 246
 247 #if FFETARGET_okINTEGER1
 248 #ifdef FFETARGET_32bit_longs
 249 typedef long int ffetargetInteger1;
 250 #define ffetargetInteger1_f "l"
 251 #else
 252 typedef int ffetargetInteger1;
 253 #define ffetargetInteger1_f ""
 254 #endif
 255 #endif
 256 #if FFETARGET_okINTEGER2
 257 typedef signed char ffetargetInteger2;
 258 #define ffetargetInteger2_f ""
 259 #endif
 260 #if FFETARGET_okINTEGER3
 261 typedef short int ffetargetInteger3;
 262 #define ffetargetInteger3_f ""
 263 #endif
 264 #if FFETARGET_okINTEGER4
 265 typedef long long int ffetargetInteger4;
 266 #define ffetargetInteger4_f "ll"
 267 #endif
 268 #if FFETARGET_okINTEGER5
 269 typedef ? ffetargetInteger5;
 270 #define ffetargetInteger5_f
 271 ?
 272 #endif
 273 #if FFETARGET_okINTEGER6
 274 typedef ? ffetargetInteger6;
 275 #define ffetargetInteger6_f
 276 ?
 277 #endif
 278 #if FFETARGET_okINTEGER7
 279 typedef ? ffetargetInteger7;
 280 #define ffetargetInteger7_f
 281 ?
 282 #endif
 283 #if FFETARGET_okINTEGER8
 284 typedef ? ffetargetInteger8;
 285 #define ffetargetInteger8_f
 286 ?
 287 #endif
 288 #if FFETARGET_okLOGICAL1
 289 #ifdef FFETARGET_32bit_longs
 290 typedef long int ffetargetLogical1;
 291 #define ffetargetLogical1_f "l"
 292 #else
 293 typedef int ffetargetLogical1;
 294 #define ffetargetLogical1_f ""
 295 #endif
 296 #endif
 297 #if FFETARGET_okLOGICAL2
 298 typedef signed char ffetargetLogical2;
 299 #define ffetargetLogical2_f ""
 300 #endif
 301 #if FFETARGET_okLOGICAL3
 302 typedef short int ffetargetLogical3;
 303 #define ffetargetLogical3_f ""
 304 #endif
 305 #if FFETARGET_okLOGICAL4
 306 typedef long long int ffetargetLogical4;
 307 #define ffetargetLogical4_f "ll"
 308 #endif
 309 #if FFETARGET_okLOGICAL5
 310 typedef ? ffetargetLogical5;
 311 #define ffetargetLogical5_f
 312 ?
 313 #endif
 314 #if FFETARGET_okLOGICAL6
 315 typedef ? ffetargetLogical6;
 316 #define ffetargetLogical6_f
 317 ?
 318 #endif
 319 #if FFETARGET_okLOGICAL7
 320 typedef ? ffetargetLogical7;
 321 #define ffetargetLogical7_f
 322 ?
 323 #endif
 324 #if FFETARGET_okLOGICAL8
 325 typedef ? ffetargetLogical8;
 326 #define ffetargetLogical8_f
 327 ?
 328 #endif
 329 #if FFETARGET_okREAL1
 330 typedef int ffetargetReal1;
 331 #define ffetargetReal1_f ""
 332 #define ffetarget_cvt_r1_to_rv_(in)                                     \
 333   ({ REAL_VALUE_TYPE _rv;                                               \
 334      long _in = (in);                                                   \
 335      real_from_target (&_rv, &_in, mode_for_size (32, MODE_FLOAT, 0));  \
 336      _rv; })
 337 #define ffetarget_cvt_rv_to_r1_(in, out) \
 338   ({ long _tmp; \
 339      REAL_VALUE_TO_TARGET_SINGLE ((in), _tmp); \
 340      (out) = (ffetargetReal1) _tmp; })
 341 #endif
 342 #if FFETARGET_okREAL2
 343 typedef struct { int v[2]; } ffetargetReal2;
 344 #define ffetargetReal2_f ""
 345 #define ffetarget_cvt_r2_to_rv_(in)                                     \
 346   ({ REAL_VALUE_TYPE _rv; long _tmp[2];                                 \
 347      _tmp[0] = (in)[0]; _tmp[1] = (in)[1];                              \
 348      real_from_target (&_rv, _tmp, mode_for_size (64, MODE_FLOAT, 0));  \
 349      _rv; })
 350 #define ffetarget_cvt_rv_to_r2_(in, out)                                \
 351   ({ long _tmp[2];                                                      \
 352      REAL_VALUE_TO_TARGET_DOUBLE ((in), _tmp);                          \
 353      (out)[0] = (int)_tmp[0]; (out)[1] = (int)_tmp[1]; })
 354 #endif
 355 #if FFETARGET_okREAL3
 356 typedef long ffetargetReal3[?];
 357 ?
 358 #endif
 359 #if FFETARGET_okREAL4
 360 typedef long ffetargetReal4[?];
 361 ?
 362 #endif
 363 #if FFETARGET_okREAL5
 364 typedef long ffetargetReal5[?];
 365 ?
 366 #endif
 367 #if FFETARGET_okREAL6
 368 typedef long ffetargetReal6[?];
 369 ?
 370 #endif
 371 #if FFETARGET_okREAL7
 372 typedef long ffetargetReal7[?];
 373 ?
 374 #endif
 375 #if FFETARGET_okREAL8
 376 typedef long ffetargetReal8[?];
 377 ?
 378 #endif
 379 #if FFETARGET_okCOMPLEX1
 380 struct _ffetarget_complex_1_
 381   {
 382     ffetargetReal1 real;
 383     ffetargetReal1 imaginary;
 384   };
 385 typedef struct _ffetarget_complex_1_ ffetargetComplex1;
 386 #endif
 387 #if FFETARGET_okCOMPLEX2
 388 struct _ffetarget_complex_2_
 389   {
 390     ffetargetReal2 real;
 391     ffetargetReal2 imaginary;
 392   };
 393 typedef struct _ffetarget_complex_2_ ffetargetComplex2;
 394 #endif
 395 #if FFETARGET_okCOMPLEX3
 396 struct _ffetarget_complex_3_
 397   {
 398     ffetargetReal3 real;
 399     ffetargetReal3 imaginary;
 400   };
 401 typedef struct _ffetarget_complex_3_ ffetargetComplex3;
 402 #endif
 403 #if FFETARGET_okCOMPLEX4
 404 struct _ffetarget_complex_4_
 405   {
 406     ffetargetReal4 real;
 407     ffetargetReal4 imaginary;
 408   };
 409 typedef struct _ffetarget_complex_4_ ffetargetComplex4;
 410 #endif
 411 #if FFETARGET_okCOMPLEX5
 412 struct _ffetarget_complex_5_
 413   {
 414     ffetargetReal5 real;
 415     ffetargetReal5 imaginary;
 416   };
 417 typedef struct _ffetarget_complex_5_ ffetargetComplex5;
 418 #endif
 419 #if FFETARGET_okCOMPLEX6
 420 struct _ffetarget_complex_6_
 421   {
 422     ffetargetReal6 real;
 423     ffetargetReal6 imaginary;
 424   };
 425 typedef struct _ffetarget_complex_6_ ffetargetComplex6;
 426 #endif
 427 #if FFETARGET_okCOMPLEX7
 428 struct _ffetarget_complex_7_
 429   {
 430     ffetargetReal7 real;
 431     ffetargetReal7 imaginary;
 432   };
 433 typedef struct _ffetarget_complex_7_ ffetargetComplex7;
 434 #endif
 435 #if FFETARGET_okCOMPLEX8
 436 struct _ffetarget_complex_8_
 437   {
 438     ffetargetReal8 real;
 439     ffetargetReal8 imaginary;
 440   };
 441 typedef struct _ffetarget_complex_8_ ffetargetComplex8;
 442 #endif
 443 #if FFETARGET_okCHARACTER1
 444 struct _ffetarget_char_1_
 445   {
 446     ffetargetCharacterSize length;
 447     unsigned char *text;
 448   };
 449 typedef struct _ffetarget_char_1_ ffetargetCharacter1;
 450 typedef unsigned char ffetargetCharacterUnit1;
 451 #endif
 452 #if FFETARGET_okCHARACTER2
 453 typedef ? ffetargetCharacter2;
 454 typedef ? ffetargetCharacterUnit2;
 455 #endif
 456 #if FFETARGET_okCHARACTER3
 457 typedef ? ffetargetCharacter3;
 458 typedef ? ffetargetCharacterUnit3;
 459 #endif
 460 #if FFETARGET_okCHARACTER4
 461 typedef ? ffetargetCharacter4;
 462 typedef ? ffetargetCharacterUnit4;
 463 #endif
 464 #if FFETARGET_okCHARACTER5
 465 typedef ? ffetargetCharacter5;
 466 typedef ? ffetargetCharacterUnit5;
 467 #endif
 468 #if FFETARGET_okCHARACTER6
 469 typedef ? ffetargetCharacter6;
 470 typedef ? ffetargetCharacterUnit6;
 471 #endif
 472 #if FFETARGET_okCHARACTER7
 473 typedef ? ffetargetCharacter7;
 474 typedef ? ffetargetCharacterUnit7;
 475 #endif
 476 #if FFETARGET_okCHARACTER8
 477 typedef ? ffetargetCharacter8;
 478 typedef ? ffetargetCharacterUnit8;
 479 #endif
 480
 481 typedef unsigned long long int ffetargetTypeless;
 482
 483 struct _ffetarget_hollerith_
 484   {
 485     ffetargetHollerithSize length;
 486     unsigned char *text;
 487   };
 488 typedef struct _ffetarget_hollerith_ ffetargetHollerith;
 489
 490 typedef ffetargetCharacter1 ffetargetCharacterDefault;
 491 typedef ffetargetComplex1 ffetargetComplexDefault;
 492 #if FFETARGET_okCOMPLEXDOUBLE
 493 typedef ffetargetComplex2 ffetargetComplexDouble;
 494 #endif
 495 #if FFETARGET_okCOMPLEXQUAD
 496 typedef ffetargetComplex3 ffetargetComplexQuad;
 497 #endif
 498 typedef ffetargetInteger1 ffetargetIntegerDefault;
 499 #define ffetargetIntegerDefault_f ffetargetInteger1_f
 500 typedef ffetargetLogical1 ffetargetLogicalDefault;
 501 #define ffetargetLogicalDefault_f ffetargetLogical1_f
 502 typedef ffetargetReal1 ffetargetRealDefault;
 503 #define ffetargetRealDefault_f ffetargetReal1_f
 504 typedef ffetargetReal2 ffetargetRealDouble;
 505 #define ffetargetRealDouble_f ffetargetReal2_f
 506 #if FFETARGET_okREALQUAD
 507 typedef ffetargetReal3 ffetargetRealQuad;
 508 #define ffetargetRealQuad_f ffetargetReal3_f
 509 #endif
 510
 511 /* Include files needed by this one. */
 512
 513 #include "bad.h"
 514 #include "info.h"
 515 #include "lex.h"
 516 #include "malloc.h"
 517
 518 /* Structure definitions. */
 519
 520
 521 /* Global objects accessed by users of this module. */
 522
 523 extern char ffetarget_string_[40];      /* Temp for ascii-to-double (atof). */
 524 extern HOST_WIDE_INT ffetarget_long_val_;
 525 extern HOST_WIDE_INT ffetarget_long_junk_;
 526
 527 /* Declare functions with prototypes. */
 528
 529 void ffetarget_aggregate_info (ffeinfoBasictype *ebt, ffeinfoKindtype *ekt,
 530                                ffetargetAlign *units, ffeinfoBasictype abt,
 531                                ffeinfoKindtype akt);
 532 ffetargetAlign ffetarget_align (ffetargetAlign *updated_alignment,
 533                                 ffetargetAlign *updated_modulo,
 534                                 ffetargetOffset offset,
 535                                 ffetargetAlign alignment,
 536                                 ffetargetAlign modulo);
 537 #if FFETARGET_okCHARACTER1
 538 bool ffetarget_character1 (ffetargetCharacter1 *val, ffelexToken character,
 539                            mallocPool pool);
 540 int ffetarget_cmp_character1 (ffetargetCharacter1 l, ffetargetCharacter1 r);
 541 ffebad ffetarget_concatenate_character1 (ffetargetCharacter1 *res,
 542                                          ffetargetCharacter1 l,
 543                                          ffetargetCharacter1 r,
 544                                          mallocPool pool,
 545                                          ffetargetCharacterSize *len);
 546 ffebad ffetarget_convert_character1_character1 (ffetargetCharacter1 *res,
 547                                             ffetargetCharacterSize res_size,
 548                                                 ffetargetCharacter1 l,
 549                                                 mallocPool pool);
 550 ffebad ffetarget_convert_character1_hollerith (ffetargetCharacter1 *res,
 551                                             ffetargetCharacterSize res_size,
 552                                                ffetargetHollerith l,
 553                                                mallocPool pool);
 554 ffebad ffetarget_convert_character1_integer4 (ffetargetCharacter1 *res,
 555                                               ffetargetCharacterSize res_size,
 556                                               ffetargetInteger4 l,
 557                                               mallocPool pool);
 558 ffebad ffetarget_convert_character1_logical4 (ffetargetCharacter1 *res,
 559                                               ffetargetCharacterSize res_size,
 560                                               ffetargetLogical4 l,
 561                                               mallocPool pool);
 562 ffebad ffetarget_convert_character1_typeless (ffetargetCharacter1 *res,
 563                                             ffetargetCharacterSize res_size,
 564                                               ffetargetTypeless l,
 565                                               mallocPool pool);
 566 ffebad ffetarget_eq_character1 (bool *res, ffetargetCharacter1 l,
 567                                 ffetargetCharacter1 r);
 568 ffebad ffetarget_le_character1 (bool *res, ffetargetCharacter1 l,
 569                                 ffetargetCharacter1 r);
 570 ffebad ffetarget_ge_character1 (bool *res, ffetargetCharacter1 l,
 571                                 ffetargetCharacter1 r);
 572 ffebad ffetarget_gt_character1 (bool *res, ffetargetCharacter1 l,
 573                                 ffetargetCharacter1 r);
 574 ffebad ffetarget_lt_character1 (bool *res, ffetargetCharacter1 l,
 575                                 ffetargetCharacter1 r);
 576 ffebad ffetarget_ne_character1 (bool *res, ffetargetCharacter1 l,
 577                                 ffetargetCharacter1 r);
 578 ffebad ffetarget_substr_character1 (ffetargetCharacter1 *res,
 579                                     ffetargetCharacter1 l,
 580                                     ffetargetCharacterSize first,
 581                                     ffetargetCharacterSize last,
 582                                     mallocPool pool,
 583                                     ffetargetCharacterSize *len);
 584 #endif
 585 int ffetarget_cmp_hollerith (ffetargetHollerith l, ffetargetHollerith r);
 586 bool ffetarget_hollerith (ffetargetHollerith *val, ffelexToken hollerith,
 587                           mallocPool pool);
 588 int ffetarget_cmp_typeless (ffetargetTypeless l, ffetargetTypeless r);
 589 ffebad ffetarget_convert_any_character1_ (char *res, size_t size,
 590                                           ffetargetCharacter1 l);
 591 ffebad ffetarget_convert_any_hollerith_ (char *res, size_t size,
 592                                          ffetargetHollerith l);
 593 ffebad ffetarget_convert_any_typeless_ (char *res, size_t size,
 594                                         ffetargetTypeless l);
 595 #if FFETARGET_okCOMPLEX1
 596 ffebad ffetarget_divide_complex1 (ffetargetComplex1 *res, ffetargetComplex1 l,
 597                                   ffetargetComplex1 r);
 598 #endif
 599 #if FFETARGET_okCOMPLEX2
 600 ffebad ffetarget_divide_complex2 (ffetargetComplex2 *res, ffetargetComplex2 l,
 601                                   ffetargetComplex2 r);
 602 #endif
 603 #if FFETARGET_okCOMPLEX3
 604 ffebad ffetarget_divide_complex3 (ffetargetComplex3 *res, ffetargetComplex3 l,
 605                                   ffetargetComplex3 r);
 606 #endif
 607 #if FFETARGET_okCOMPLEX4
 608 ffebad ffetarget_divide_complex4 (ffetargetComplex4 *res, ffetargetComplex4 l,
 609                                   ffetargetComplex4 r);
 610 #endif
 611 #if FFETARGET_okCOMPLEX5
 612 ffebad ffetarget_divide_complex5 (ffetargetComplex5 *res, ffetargetComplex5 l,
 613                                   ffetargetComplex5 r);
 614 #endif
 615 #if FFETARGET_okCOMPLEX6
 616 ffebad ffetarget_divide_complex6 (ffetargetComplex6 *res, ffetargetComplex6 l,
 617                                   ffetargetComplex6 r);
 618 #endif
 619 #if FFETARGET_okCOMPLEX7
 620 ffebad ffetarget_divide_complex7 (ffetargetComplex7 *res, ffetargetComplex7 l,
 621                                   ffetargetComplex7 r);
 622 #endif
 623 #if FFETARGET_okCOMPLEX8
 624 ffebad ffetarget_divide_complex8 (ffetargetComplex8 *res, ffetargetComplex8 l,
 625                                   ffetargetComplex8 r);
 626 #endif
 627 #if FFETARGET_okINTEGER1
 628 bool ffetarget_integer1 (ffetargetInteger1 *val, ffelexToken integer);
 629 #endif
 630 #if FFETARGET_okINTEGER2
 631 bool ffetarget_integer2 (ffetargetInteger2 *val, ffelexToken integer);
 632 #endif
 633 #if FFETARGET_okINTEGER3
 634 bool ffetarget_integer3 (ffetargetInteger3 *val, ffelexToken integer);
 635 #endif
 636 #if FFETARGET_okINTEGER4
 637 bool ffetarget_integer4 (ffetargetInteger4 *val, ffelexToken integer);
 638 #endif
 639 #if FFETARGET_okINTEGER5
 640 bool ffetarget_integer5 (ffetargetInteger5 *val, ffelexToken integer);
 641 #endif
 642 #if FFETARGET_okINTEGER6
 643 bool ffetarget_integer6 (ffetargetInteger6 *val, ffelexToken integer);
 644 #endif
 645 #if FFETARGET_okINTEGER7
 646 bool ffetarget_integer7 (ffetargetInteger7 *val, ffelexToken integer);
 647 #endif
 648 #if FFETARGET_okINTEGER8
 649 bool ffetarget_integer8 (ffetargetInteger8 *val, ffelexToken integer);
 650 #endif
 651 bool ffetarget_integerbinary (ffetargetIntegerDefault *val,
 652                              ffelexToken integer);
 653 bool ffetarget_integerhex (ffetargetIntegerDefault *val,
 654                              ffelexToken integer);
 655 bool ffetarget_integeroctal (ffetargetIntegerDefault *val,
 656                              ffelexToken integer);
 657 void ffetarget_integer_bad_magical (ffelexToken t);
 658 void ffetarget_integer_bad_magical_binary (ffelexToken integer, ffelexToken minus);
 659 void ffetarget_integer_bad_magical_precedence (ffelexToken integer,
 660                                                ffelexToken uminus,
 661                                                ffelexToken higher_op);
 662 void ffetarget_integer_bad_magical_precedence_binary (ffelexToken integer,
 663                                                       ffelexToken minus,
 664                                                       ffelexToken higher_op);
 665 #if FFETARGET_okCHARACTER1
 666 bool ffetarget_iszero_character1 (ffetargetCharacter1 constant);
 667 #endif
 668 bool ffetarget_iszero_hollerith (ffetargetHollerith constant);
 669 void ffetarget_layout (const char *error_text, ffetargetAlign *alignment,
 670                        ffetargetAlign *modulo, ffetargetOffset *size,
 671                        ffeinfoBasictype bt, ffeinfoKindtype kt,
 672                        ffetargetCharacterSize charsize,
 673                        ffetargetIntegerDefault num_elements);
 674 #if FFETARGET_okCOMPLEX1
 675 ffebad ffetarget_multiply_complex1 (ffetargetComplex1 *res,
 676                                     ffetargetComplex1 l,
 677                                     ffetargetComplex1 r);
 678 #endif
 679 #if FFETARGET_okCOMPLEX2
 680 ffebad ffetarget_multiply_complex2 (ffetargetComplex2 *res,
 681                                     ffetargetComplex2 l,
 682                                     ffetargetComplex2 r);
 683 #endif
 684 #if FFETARGET_okCOMPLEX3
 685 ffebad ffetarget_multiply_complex3 (ffetargetComplex3 *res,
 686                                     ffetargetComplex3 l,
 687                                     ffetargetComplex3 r);
 688 #endif
 689 #if FFETARGET_okCOMPLEX4
 690 ffebad ffetarget_multiply_complex4 (ffetargetComplex4 *res,
 691                                     ffetargetComplex4 l,
 692                                     ffetargetComplex4 r);
 693 #endif
 694 #if FFETARGET_okCOMPLEX5
 695 ffebad ffetarget_multiply_complex5 (ffetargetComplex5 *res,
 696                                     ffetargetComplex5 l,
 697                                     ffetargetComplex5 r);
 698 #endif
 699 #if FFETARGET_okCOMPLEX6
 700 ffebad ffetarget_multiply_complex6 (ffetargetComplex6 *res,
 701                                     ffetargetComplex6 l,
 702                                     ffetargetComplex6 r);
 703 #endif
 704 #if FFETARGET_okCOMPLEX7
 705 ffebad ffetarget_multiply_complex7 (ffetargetComplex7 *res,
 706                                     ffetargetComplex7 l,
 707                                     ffetargetComplex7 r);
 708 #endif
 709 #if FFETARGET_okCOMPLEX8
 710 ffebad ffetarget_multiply_complex8 (ffetargetComplex8 *res,
 711                                     ffetargetComplex8 l,
 712                                     ffetargetComplex8 r);
 713 #endif
 714 ffebad ffetarget_power_complexdefault_integerdefault (ffetargetComplexDefault *res,
 715                                                   ffetargetComplexDefault l,
 716                                                  ffetargetIntegerDefault r);
 717 #if FFETARGET_okCOMPLEXDOUBLE
 718 ffebad ffetarget_power_complexdouble_integerdefault (ffetargetComplexDouble *res,
 719                                                    ffetargetComplexDouble l,
 720                                                  ffetargetIntegerDefault r);
 721 #endif
 722 ffebad ffetarget_power_integerdefault_integerdefault (ffetargetIntegerDefault *res,
 723                                                   ffetargetIntegerDefault l,
 724                                                  ffetargetIntegerDefault r);
 725 ffebad ffetarget_power_realdefault_integerdefault (ffetargetRealDefault *res,
 726                                                    ffetargetRealDefault l,
 727                                                  ffetargetIntegerDefault r);
 728 ffebad ffetarget_power_realdouble_integerdefault (ffetargetRealDouble *res,
 729                                                   ffetargetRealDouble l,
 730                                                   ffetargetIntegerDefault r);
 731 void ffetarget_print_binary (FILE *f, ffetargetTypeless val);
 732 void ffetarget_print_character1 (FILE *f, ffetargetCharacter1 val);
 733 void ffetarget_print_hollerith (FILE *f, ffetargetHollerith val);
 734 void ffetarget_print_octal (FILE *f, ffetargetTypeless val);
 735 void ffetarget_print_hex (FILE *f, ffetargetTypeless val);
 736 #if FFETARGET_okREAL1
 737 bool ffetarget_real1 (ffetargetReal1 *value, ffelexToken integer,
 738                       ffelexToken decimal, ffelexToken fraction,
 739                       ffelexToken exponent, ffelexToken exponent_sign,
 740                       ffelexToken exponent_digits);
 741 #endif
 742 #if FFETARGET_okREAL2
 743 bool ffetarget_real2 (ffetargetReal2 *value, ffelexToken integer,
 744                       ffelexToken decimal, ffelexToken fraction,
 745                       ffelexToken exponent, ffelexToken exponent_sign,
 746                       ffelexToken exponent_digits);
 747 #endif
 748 #if FFETARGET_okREAL3
 749 bool ffetarget_real3 (ffetargetReal3 *value, ffelexToken integer,
 750                       ffelexToken decimal, ffelexToken fraction,
 751                       ffelexToken exponent, ffelexToken exponent_sign,
 752                       ffelexToken exponent_digits);
 753 #endif
 754 #if FFETARGET_okREAL4
 755 bool ffetarget_real4 (ffetargetReal4 *value, ffelexToken integer,
 756                       ffelexToken decimal, ffelexToken fraction,
 757                       ffelexToken exponent, ffelexToken exponent_sign,
 758                       ffelexToken exponent_digits);
 759 #endif
 760 #if FFETARGET_okREAL5
 761 bool ffetarget_real5 (ffetargetReal5 *value, ffelexToken integer,
 762                       ffelexToken decimal, ffelexToken fraction,
 763                       ffelexToken exponent, ffelexToken exponent_sign,
 764                       ffelexToken exponent_digits);
 765 #endif
 766 #if FFETARGET_okREAL6
 767 bool ffetarget_real6 (ffetargetReal6 *value, ffelexToken integer,
 768                       ffelexToken decimal, ffelexToken fraction,
 769                       ffelexToken exponent, ffelexToken exponent_sign,
 770                       ffelexToken exponent_digits);
 771 #endif
 772 #if FFETARGET_okREAL7
 773 bool ffetarget_real7 (ffetargetReal7 *value, ffelexToken integer,
 774                       ffelexToken decimal, ffelexToken fraction,
 775                       ffelexToken exponent, ffelexToken exponent_sign,
 776                       ffelexToken exponent_digits);
 777 #endif
 778 #if FFETARGET_okREAL8
 779 bool ffetarget_real8 (ffetargetReal8 *value, ffelexToken integer,
 780                       ffelexToken decimal, ffelexToken fraction,
 781                       ffelexToken exponent, ffelexToken exponent_sign,
 782                       ffelexToken exponent_digits);
 783 #endif
 784 bool ffetarget_typeless_binary (ffetargetTypeless *value, ffelexToken token);
 785 bool ffetarget_typeless_octal (ffetargetTypeless *value, ffelexToken token);
 786 bool ffetarget_typeless_hex (ffetargetTypeless *value, ffelexToken token);
 787 void ffetarget_verify_character1 (mallocPool pool, ffetargetCharacter1 val);
 788 int ffetarget_num_digits_ (ffelexToken t);
 789 void *ffetarget_memcpy_ (void *dst, void *src, size_t len);
 790
 791 /* Define macros. */
 792
 793 #define FFETARGET_REAL_VALUE_FROM_INT_(resr, lf, kt)                    \
 794   REAL_VALUE_FROM_INT (resr, (long) lf, (long) ((lf < 0) ? -1 : 0),     \
 795                        ((kt == 1) ? SFmode : DFmode))
 796
 797 #define ffetarget_add_complex1(res,l,r) \
 798   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
 799      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
 800      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
 801      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
 802      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
 803      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
 804      REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
 805      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
 806      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
 807      FFEBAD; })
 808 #define ffetarget_add_complex2(res,l,r) \
 809   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
 810      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
 811      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
 812      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
 813      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
 814      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
 815      REAL_ARITHMETIC (resi, PLUS_EXPR, li, ri); \
 816      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
 817      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
 818      FFEBAD; })
 819 #define ffetarget_add_integer1(res,l,r) (*(res) = (l) + (r), FFEBAD)
 820 #define ffetarget_add_integer2(res,l,r) (*(res) = (l) + (r), FFEBAD)
 821 #define ffetarget_add_integer3(res,l,r) (*(res) = (l) + (r), FFEBAD)
 822 #define ffetarget_add_integer4(res,l,r) (*(res) = (l) + (r), FFEBAD)
 823 #define ffetarget_add_real1(res,l,r) \
 824   ({ REAL_VALUE_TYPE lr, rr, resr; \
 825      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
 826      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
 827      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
 828      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
 829      FFEBAD; })
 830 #define ffetarget_add_real2(res,l,r) \
 831   ({ REAL_VALUE_TYPE lr, rr, resr; \
 832      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
 833      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
 834      REAL_ARITHMETIC (resr, PLUS_EXPR, lr, rr); \
 835      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
 836      FFEBAD; })
 837 #define ffetarget_aggregate_ptr_memcpy(dbt,dkt,sbt,skt) \
 838   ((ffetargetCopyfunc) ffetarget_memcpy_)
 839 #define ffetarget_and_integer1(res,l,r) (*(res) = (l) & (r), FFEBAD)
 840 #define ffetarget_and_integer2(res,l,r) (*(res) = (l) & (r), FFEBAD)
 841 #define ffetarget_and_integer3(res,l,r) (*(res) = (l) & (r), FFEBAD)
 842 #define ffetarget_and_integer4(res,l,r) (*(res) = (l) & (r), FFEBAD)
 843 #define ffetarget_and_logical1(res,l,r) (*(res) = (l) && (r), FFEBAD)
 844 #define ffetarget_and_logical2(res,l,r) (*(res) = (l) && (r), FFEBAD)
 845 #define ffetarget_and_logical3(res,l,r) (*(res) = (l) && (r), FFEBAD)
 846 #define ffetarget_and_logical4(res,l,r) (*(res) = (l) && (r), FFEBAD)
 847 #define ffetarget_binarymil(v,t) ffetarget_typeless_binary (v, t)
 848 #define ffetarget_binaryvxt(v,t) ffetarget_typeless_binary (v, t)
 849 #define ffetarget_cmp_integer1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 850 #define ffetarget_cmp_integer2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 851 #define ffetarget_cmp_integer3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 852 #define ffetarget_cmp_integer4(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 853 #define ffetarget_cmp_logical1(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 854 #define ffetarget_cmp_logical2(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 855 #define ffetarget_cmp_logical3(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 856 #define ffetarget_cmp_logical4(l,r) ((l) == (r) ? 0 : ((l) < (r) ? -1 : 1))
 857 #define ffetarget_cmp_real1(l,r) memcmp (&(l), &(r), sizeof(l))
 858 #define ffetarget_cmp_real2(l,r) memcmp (&(l), &(r), sizeof(l))
 859 #define ffetarget_cmp_real3(l,r) memcmp (&(l), &(r), sizeof(l))
 860 #define ffetarget_cmp_typeless(l,r) \
 861   memcmp (&(l), &(r), sizeof ((l)))
 862 #define ffetarget_convert_character1_integer1(res,res_size,l,pool) \
 863         ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool)
 864 #define ffetarget_convert_character1_integer2(res,res_size,l,pool) \
 865         ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool)
 866 #define ffetarget_convert_character1_integer3(res,res_size,l,pool) \
 867         ffetarget_convert_character1_integer4(res,res_size,(ffetargetInteger4)l,pool)
 868 #define ffetarget_convert_character1_logical1(res,res_size,l,pool) \
 869         ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool)
 870 #define ffetarget_convert_character1_logical2(res,res_size,l,pool) \
 871         ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool)
 872 #define ffetarget_convert_character1_logical3(res,res_size,l,pool) \
 873         ffetarget_convert_character1_logical4(res,res_size,(ffetargetLogical4)l,pool)
 874 #define ffetarget_convert_complex1_character1(res,l) \
 875   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
 876 #define ffetarget_convert_complex1_hollerith(res,l) \
 877   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
 878 #define ffetarget_convert_complex1_typeless(res,l) \
 879   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
 880 #define ffetarget_convert_complex1_complex2(res,l) \
 881   ({ REAL_VALUE_TYPE lr, li; \
 882      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
 883      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
 884      ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \
 885      ffetarget_cvt_rv_to_r1_ (li, (res)->imaginary), \
 886      FFEBAD; })
 887 #define ffetarget_convert_complex1_integer(res,l) \
 888   ({ REAL_VALUE_TYPE resi, resr; \
 889      ffetargetInteger1 lf = (l); \
 890      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \
 891      resi = dconst0; \
 892      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
 893      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
 894      FFEBAD; })
 895 #define ffetarget_convert_complex1_integer1 ffetarget_convert_complex1_integer
 896 #define ffetarget_convert_complex1_integer2 ffetarget_convert_complex1_integer
 897 #define ffetarget_convert_complex1_integer3 ffetarget_convert_complex1_integer
 898 #define ffetarget_convert_complex1_integer4(res,l) FFEBAD_NOCANDO
 899 #define ffetarget_convert_complex1_real1(res,l) \
 900   ((res)->real = (l), \
 901    ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \
 902    FFEBAD)
 903 #define ffetarget_convert_complex1_real2(res,l) \
 904   ({ REAL_VALUE_TYPE lr; \
 905      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
 906      ffetarget_cvt_rv_to_r1_ (lr, (res)->real); \
 907      ffetarget_cvt_rv_to_r1_ (dconst0, (res)->imaginary), \
 908      FFEBAD; })
 909 #define ffetarget_convert_complex2_character1(res,l) \
 910   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
 911 #define ffetarget_convert_complex2_hollerith(res,l) \
 912   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
 913 #define ffetarget_convert_complex2_typeless(res,l) \
 914   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
 915 #define ffetarget_convert_complex2_complex1(res,l) \
 916   ({ REAL_VALUE_TYPE lr, li; \
 917      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
 918      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
 919      ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \
 920      ffetarget_cvt_rv_to_r2_ (li, &((res)->imaginary.v[0])), \
 921      FFEBAD; })
 922 #define ffetarget_convert_complex2_integer(res,l) \
 923   ({ REAL_VALUE_TYPE resi, resr; \
 924      ffetargetInteger1 lf = (l); \
 925      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 2); \
 926      resi = dconst0; \
 927      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
 928      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
 929      FFEBAD; })
 930 #define ffetarget_convert_complex2_integer1 ffetarget_convert_complex2_integer
 931 #define ffetarget_convert_complex2_integer2 ffetarget_convert_complex2_integer
 932 #define ffetarget_convert_complex2_integer3 ffetarget_convert_complex2_integer
 933 #define ffetarget_convert_complex2_integer4(res,l) FFEBAD_NOCANDO
 934 #define ffetarget_convert_complex2_real1(res,l) \
 935   ({ REAL_VALUE_TYPE lr; \
 936      lr = ffetarget_cvt_r1_to_rv_ (l); \
 937      ffetarget_cvt_rv_to_r2_ (lr, &((res)->real.v[0])); \
 938      ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \
 939      FFEBAD; })
 940 #define ffetarget_convert_complex2_real2(res,l) \
 941   ((res)->real = (l), \
 942    ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->imaginary.v[0])), \
 943    FFEBAD)
 944 #define ffetarget_convert_integer2_character1(res,l) \
 945         ffetarget_convert_integer1_character1(res,l)
 946 #define ffetarget_convert_integer2_complex1(res,l) \
 947         ffetarget_convert_integer1_complex1(res,l)
 948 #define ffetarget_convert_integer2_complex2(res,l) \
 949         ffetarget_convert_integer1_complex2(res,l)
 950 #define ffetarget_convert_integer2_hollerith(res,l) \
 951         ffetarget_convert_integer1_hollerith(res,l)
 952 #define ffetarget_convert_integer2_integer1(res,l) (*(res) = (l), FFEBAD)
 953 #define ffetarget_convert_integer2_integer3(res,l) (*(res) = (l), FFEBAD)
 954 #define ffetarget_convert_integer2_integer4(res,l) (*(res) = (l), FFEBAD)
 955 #define ffetarget_convert_integer2_logical1(res,l) \
 956         ffetarget_convert_integer1_logical1(res,l)
 957 #define ffetarget_convert_integer2_logical2(res,l) \
 958         ffetarget_convert_integer2_logical1(res,l)
 959 #define ffetarget_convert_integer2_logical3(res,l) \
 960         ffetarget_convert_integer2_logical1(res,l)
 961 #define ffetarget_convert_integer2_logical4(res,l) \
 962         ffetarget_convert_integer2_logical1(res,l)
 963 #define ffetarget_convert_integer2_real1(res,l) \
 964         ffetarget_convert_integer1_real1(res,l)
 965 #define ffetarget_convert_integer2_real2(res,l) \
 966         ffetarget_convert_integer1_real2(res,l)
 967 #define ffetarget_convert_integer2_typeless(res,l) \
 968         ffetarget_convert_integer1_typeless(res,l)
 969 #define ffetarget_convert_integer3_character1(res,l) \
 970         ffetarget_convert_integer1_character1(res,l)
 971 #define ffetarget_convert_integer3_complex1(res,l) \
 972         ffetarget_convert_integer1_complex1(res,l)
 973 #define ffetarget_convert_integer3_complex2(res,l) \
 974         ffetarget_convert_integer1_complex2(res,l)
 975 #define ffetarget_convert_integer3_hollerith(res,l) \
 976         ffetarget_convert_integer1_hollerith(res,l)
 977 #define ffetarget_convert_integer3_integer1(res,l) (*(res) = (l), FFEBAD)
 978 #define ffetarget_convert_integer3_integer2(res,l) (*(res) = (l), FFEBAD)
 979 #define ffetarget_convert_integer3_integer4(res,l) (*(res) = (l), FFEBAD)
 980 #define ffetarget_convert_integer3_logical1(res,l) \
 981         ffetarget_convert_integer1_logical1(res,l)
 982 #define ffetarget_convert_integer3_logical2(res,l) \
 983         ffetarget_convert_integer3_logical1(res,l)
 984 #define ffetarget_convert_integer3_logical3(res,l) \
 985         ffetarget_convert_integer3_logical1(res,l)
 986 #define ffetarget_convert_integer3_logical4(res,l) \
 987         ffetarget_convert_integer3_logical1(res,l)
 988 #define ffetarget_convert_integer3_real1(res,l) \
 989         ffetarget_convert_integer1_real1(res,l)
 990 #define ffetarget_convert_integer3_real2(res,l) \
 991         ffetarget_convert_integer1_real2(res,l)
 992 #define ffetarget_convert_integer3_typeless(res,l) \
 993         ffetarget_convert_integer1_typeless(res,l)
 994 #define ffetarget_convert_integer4_character1(res,l) \
 995         ffetarget_convert_integer1_character1(res,l)
 996 #define ffetarget_convert_integer4_complex1(res,l) FFEBAD_NOCANDO
 997 #define ffetarget_convert_integer4_complex2(res,l) FFEBAD_NOCANDO
 998 #define ffetarget_convert_integer4_hollerith(res,l) \
 999         ffetarget_convert_integer1_hollerith(res,l)
1000 #define ffetarget_convert_integer4_integer1(res,l) (*(res) = (l), FFEBAD)
1001 #define ffetarget_convert_integer4_integer2(res,l) (*(res) = (l), FFEBAD)
1002 #define ffetarget_convert_integer4_integer3(res,l) (*(res) = (l), FFEBAD)
1003 #define ffetarget_convert_integer4_logical1(res,l) \
1004         ffetarget_convert_integer1_logical1(res,l)
1005 #define ffetarget_convert_integer4_logical2(res,l) \
1006         ffetarget_convert_integer1_logical1(res,l)
1007 #define ffetarget_convert_integer4_logical3(res,l) \
1008         ffetarget_convert_integer1_logical1(res,l)
1009 #define ffetarget_convert_integer4_logical4(res,l) \
1010         ffetarget_convert_integer1_logical1(res,l)
1011 #define ffetarget_convert_integer4_real1(res,l) FFEBAD_NOCANDO
1012 #define ffetarget_convert_integer4_real2(res,l) FFEBAD_NOCANDO
1013 #define ffetarget_convert_integer4_typeless(res,l) \
1014         ffetarget_convert_integer1_typeless(res,l)
1015 #define ffetarget_convert_logical1_character1(res,l) \
1016   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1017 #define ffetarget_convert_logical1_hollerith(res,l) \
1018   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1019 #define ffetarget_convert_logical1_typeless(res,l) \
1020   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1021 #define ffetarget_convert_logical1_logical2(res,l) (*(res) = (l), FFEBAD)
1022 #define ffetarget_convert_logical1_logical3(res,l) (*(res) = (l), FFEBAD)
1023 #define ffetarget_convert_logical1_logical4(res,l) (*(res) = (l), FFEBAD)
1024 #define ffetarget_convert_logical1_integer1(res,l) (*(res) = (l), FFEBAD)
1025 #define ffetarget_convert_logical1_integer2(res,l) (*(res) = (l), FFEBAD)
1026 #define ffetarget_convert_logical1_integer3(res,l) (*(res) = (l), FFEBAD)
1027 #define ffetarget_convert_logical1_integer4(res,l) (*(res) = (l), FFEBAD)
1028 #define ffetarget_convert_logical2_character1(res,l) \
1029   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1030 #define ffetarget_convert_logical2_hollerith(res,l) \
1031   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1032 #define ffetarget_convert_logical2_typeless(res,l) \
1033   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1034 #define ffetarget_convert_logical2_logical1(res,l) (*(res) = (l), FFEBAD)
1035 #define ffetarget_convert_logical2_logical3(res,l) (*(res) = (l), FFEBAD)
1036 #define ffetarget_convert_logical2_logical4(res,l) (*(res) = (l), FFEBAD)
1037 #define ffetarget_convert_logical2_integer1(res,l) (*(res) = (l), FFEBAD)
1038 #define ffetarget_convert_logical2_integer2(res,l) (*(res) = (l), FFEBAD)
1039 #define ffetarget_convert_logical2_integer3(res,l) (*(res) = (l), FFEBAD)
1040 #define ffetarget_convert_logical2_integer4(res,l) (*(res) = (l), FFEBAD)
1041 #define ffetarget_convert_logical3_character1(res,l) \
1042   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1043 #define ffetarget_convert_logical3_hollerith(res,l) \
1044   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1045 #define ffetarget_convert_logical3_typeless(res,l) \
1046   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1047 #define ffetarget_convert_logical3_logical1(res,l) (*(res) = (l), FFEBAD)
1048 #define ffetarget_convert_logical3_logical2(res,l) (*(res) = (l), FFEBAD)
1049 #define ffetarget_convert_logical3_logical4(res,l) (*(res) = (l), FFEBAD)
1050 #define ffetarget_convert_logical3_integer1(res,l) (*(res) = (l), FFEBAD)
1051 #define ffetarget_convert_logical3_integer2(res,l) (*(res) = (l), FFEBAD)
1052 #define ffetarget_convert_logical3_integer3(res,l) (*(res) = (l), FFEBAD)
1053 #define ffetarget_convert_logical3_integer4(res,l) (*(res) = (l), FFEBAD)
1054 #define ffetarget_convert_logical4_character1(res,l) \
1055   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1056 #define ffetarget_convert_logical4_hollerith(res,l) \
1057   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1058 #define ffetarget_convert_logical4_typeless(res,l) \
1059   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1060 #define ffetarget_convert_logical4_logical1(res,l) (*(res) = (l), FFEBAD)
1061 #define ffetarget_convert_logical4_logical2(res,l) (*(res) = (l), FFEBAD)
1062 #define ffetarget_convert_logical4_logical3(res,l) (*(res) = (l), FFEBAD)
1063 #define ffetarget_convert_logical4_integer1(res,l) (*(res) = (l), FFEBAD)
1064 #define ffetarget_convert_logical4_integer2(res,l) (*(res) = (l), FFEBAD)
1065 #define ffetarget_convert_logical4_integer3(res,l) (*(res) = (l), FFEBAD)
1066 #define ffetarget_convert_logical4_integer4(res,l) (*(res) = (l), FFEBAD)
1067 #define ffetarget_convert_integer1_character1(res,l) \
1068   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1069 #define ffetarget_convert_integer1_hollerith(res,l) \
1070   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1071 #define ffetarget_convert_integer1_typeless(res,l) \
1072   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1073 #define ffetarget_convert_integer1_integer2(res,l) (*(res) = (l), FFEBAD)
1074 #define ffetarget_convert_integer1_integer3(res,l) (*(res) = (l), FFEBAD)
1075 #define ffetarget_convert_integer1_integer4(res,l) (*(res) = (l), FFEBAD)
1076 #define ffetarget_convert_integer1_logical1(res,l) (*(res) = (l), FFEBAD)
1077 #define ffetarget_convert_integer1_logical2(res,l) (*(res) = (l), FFEBAD)
1078 #define ffetarget_convert_integer1_logical3(res,l) (*(res) = (l), FFEBAD)
1079 #define ffetarget_convert_integer1_logical4(res,l) (*(res) = (l), FFEBAD)
1080 #define ffetarget_convert_integer1_real1(res,l) \
1081   ({ REAL_VALUE_TYPE lr; \
1082      lr = ffetarget_cvt_r1_to_rv_ (l); \
1083      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
1084      *(res) = ffetarget_long_val_; \
1085      FFEBAD; })
1086 #define ffetarget_convert_integer1_real2(res,l) \
1087   ({ REAL_VALUE_TYPE lr; \
1088      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1089      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
1090      *(res) = ffetarget_long_val_; \
1091      FFEBAD; })
1092 #define ffetarget_convert_integer1_complex1(res,l) \
1093   ({ REAL_VALUE_TYPE lr; \
1094      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
1095      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
1096      *(res) = ffetarget_long_val_; \
1097      FFEBAD; })
1098 #define ffetarget_convert_integer1_complex2(res,l) \
1099   ({ REAL_VALUE_TYPE lr; \
1100      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
1101      REAL_VALUE_TO_INT (&ffetarget_long_val_, &ffetarget_long_junk_, lr); \
1102      *(res) = ffetarget_long_val_; \
1103      FFEBAD; })
1104 #define ffetarget_convert_real1_character1(res,l) \
1105   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1106 #define ffetarget_convert_real1_hollerith(res,l) \
1107   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1108 #define ffetarget_convert_real1_integer2(res,l) \
1109         ffetarget_convert_real1_integer1(res,l)
1110 #define ffetarget_convert_real1_integer3(res,l) \
1111         ffetarget_convert_real1_integer1(res,l)
1112 #define ffetarget_convert_real1_integer4(res,l) FFEBAD_NOCANDO
1113 #define ffetarget_convert_real1_typeless(res,l) \
1114   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1115 #define ffetarget_convert_real1_complex1(res,l) (*(res) = (l).real, FFEBAD)
1116 #define ffetarget_convert_real1_complex2(res,l) \
1117   ffetarget_convert_real1_real2 ((res), (l).real)
1118 #define ffetarget_convert_real1_integer1(res,l) \
1119   ({ REAL_VALUE_TYPE resr; \
1120      ffetargetInteger1 lf = (l); \
1121      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 1); \
1122      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
1123      FFEBAD; })
1124 #define ffetarget_convert_real1_real2(res,l) \
1125   ({ REAL_VALUE_TYPE lr; \
1126      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1127      ffetarget_cvt_rv_to_r1_ (lr, *(res)); \
1128      FFEBAD; })
1129 #define ffetarget_convert_real2_character1(res,l) \
1130   ffetarget_convert_any_character1_ ((char *) (res), sizeof(*(res)), l)
1131 #define ffetarget_convert_real2_hollerith(res,l) \
1132   ffetarget_convert_any_hollerith_ ((char *) (res), sizeof(*(res)), l)
1133 #define ffetarget_convert_real2_integer2(res,l) \
1134         ffetarget_convert_real2_integer1(res,l)
1135 #define ffetarget_convert_real2_integer3(res,l) \
1136         ffetarget_convert_real2_integer1(res,l)
1137 #define ffetarget_convert_real2_integer4(res,l) FFEBAD_NOCANDO
1138 #define ffetarget_convert_real2_typeless(res,l) \
1139   ffetarget_convert_any_typeless_ ((char *) (res), sizeof(*(res)), l)
1140 #define ffetarget_convert_real2_complex1(res,l) \
1141   ffetarget_convert_real2_real1 ((res), (l).real)
1142 #define ffetarget_convert_real2_complex2(res,l) (*(res) = (l).real, FFEBAD)
1143 #define ffetarget_convert_real2_integer(res,l) \
1144   ({ REAL_VALUE_TYPE resr; \
1145      ffetargetInteger1 lf = (l); \
1146      FFETARGET_REAL_VALUE_FROM_INT_ (resr, lf, 2); \
1147      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
1148      FFEBAD; })
1149 #define ffetarget_convert_real2_integer1 ffetarget_convert_real2_integer
1150 #define ffetarget_convert_real2_real1(res,l) \
1151   ({ REAL_VALUE_TYPE lr; \
1152      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1153      ffetarget_cvt_rv_to_r2_ (lr, &((res)->v[0])); \
1154      FFEBAD; })
1155 #define ffetarget_divide_integer1(res,l,r) \
1156   (((r) == 0) ? (*(res) = 0, FFEBAD_DIV_BY_ZERO)  \
1157    : (((r) == -1) ? (*(res) = -(l), FFEBAD)       \
1158       : (*(res) = (l) / (r), FFEBAD)))
1159 #define ffetarget_divide_integer2(res,l,r) \
1160         ffetarget_divide_integer1(res,l,r)
1161 #define ffetarget_divide_integer3(res,l,r) \
1162         ffetarget_divide_integer1(res,l,r)
1163 #define ffetarget_divide_integer4(res,l,r) \
1164         ffetarget_divide_integer1(res,l,r)
1165 #define ffetarget_divide_real1(res,l,r) \
1166   ({ REAL_VALUE_TYPE lr, rr, resr; \
1167      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1168      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1169      REAL_VALUES_EQUAL (rr, dconst0) \
1170        ? ({ ffetarget_cvt_rv_to_r1_ (dconst0, *(res)); \
1171             FFEBAD_DIV_BY_ZERO; \
1172           }) \
1173          : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
1174               ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
1175               FFEBAD; \
1176             }); \
1177          })
1178 #define ffetarget_divide_real2(res,l,r) \
1179   ({ REAL_VALUE_TYPE lr, rr, resr; \
1180      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1181      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1182      REAL_VALUES_EQUAL (rr, dconst0) \
1183        ? ({ ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0])); \
1184             FFEBAD_DIV_BY_ZERO; \
1185           }) \
1186          : ({ REAL_ARITHMETIC (resr, RDIV_EXPR, lr, rr); \
1187               ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
1188               FFEBAD; \
1189             }); \
1190          })
1191 #define ffetarget_eq_complex1(res,l,r) \
1192   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
1193      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
1194      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
1195      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
1196      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
1197      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
1198        ? TRUE : FALSE; \
1199      FFEBAD; })
1200 #define ffetarget_eq_complex2(res,l,r) \
1201   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
1202      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
1203      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
1204      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
1205      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
1206      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
1207        ? TRUE : FALSE; \
1208      FFEBAD; })
1209 #define ffetarget_eq_integer1(res,l,r) \
1210   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
1211 #define ffetarget_eq_integer2(res,l,r) \
1212   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
1213 #define ffetarget_eq_integer3(res,l,r) \
1214   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
1215 #define ffetarget_eq_integer4(res,l,r) \
1216   (*(res) = ((l) == (r)) ? TRUE : FALSE, FFEBAD)
1217 #define ffetarget_eq_real1(res,l,r) \
1218   ({ REAL_VALUE_TYPE lr, rr; \
1219      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1220      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1221      *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
1222      FFEBAD; })
1223 #define ffetarget_eq_real2(res,l,r) \
1224   ({ REAL_VALUE_TYPE lr, rr; \
1225      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1226      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1227      *(res) = REAL_VALUES_EQUAL (lr, rr) ? TRUE : FALSE; \
1228      FFEBAD; })
1229 #define ffetarget_eqv_integer1(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
1230 #define ffetarget_eqv_integer2(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
1231 #define ffetarget_eqv_integer3(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
1232 #define ffetarget_eqv_integer4(res,l,r) (*(res) = (l) ^ ~(r), FFEBAD)
1233 #define ffetarget_eqv_logical1(res,l,r) (*(res) = (l) == (r), FFEBAD)
1234 #define ffetarget_eqv_logical2(res,l,r) (*(res) = (l) == (r), FFEBAD)
1235 #define ffetarget_eqv_logical3(res,l,r) (*(res) = (l) == (r), FFEBAD)
1236 #define ffetarget_eqv_logical4(res,l,r) (*(res) = (l) == (r), FFEBAD)
1237 #define ffetarget_ge_integer1(res,l,r) \
1238   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
1239 #define ffetarget_ge_integer2(res,l,r) \
1240   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
1241 #define ffetarget_ge_integer3(res,l,r) \
1242   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
1243 #define ffetarget_ge_integer4(res,l,r) \
1244   (*(res) = ((l) >= (r)) ? TRUE : FALSE, FFEBAD)
1245 #define ffetarget_ge_real1(res,l,r) \
1246   ({ REAL_VALUE_TYPE lr, rr; \
1247      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1248      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1249      *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
1250      FFEBAD; })
1251 #define ffetarget_ge_real2(res,l,r) \
1252   ({ REAL_VALUE_TYPE lr, rr; \
1253      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1254      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1255      *(res) = REAL_VALUES_LESS (lr, rr) ? FALSE : TRUE; \
1256      FFEBAD; })
1257 #define ffetarget_gt_integer1(res,l,r) \
1258   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
1259 #define ffetarget_gt_integer2(res,l,r) \
1260   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
1261 #define ffetarget_gt_integer3(res,l,r) \
1262   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
1263 #define ffetarget_gt_integer4(res,l,r) \
1264   (*(res) = ((l) > (r)) ? TRUE : FALSE, FFEBAD)
1265 #define ffetarget_gt_real1(res,l,r) \
1266   ({ REAL_VALUE_TYPE lr, rr; \
1267      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1268      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1269      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
1270        ? FALSE : TRUE; \
1271      FFEBAD; })
1272 #define ffetarget_gt_real2(res,l,r) \
1273   ({ REAL_VALUE_TYPE lr, rr; \
1274      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1275      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1276      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
1277        ? FALSE : TRUE; \
1278      FFEBAD; })
1279 #define ffetarget_hexxmil(v,t) ffetarget_typeless_hex (v, t)
1280 #define ffetarget_hexxvxt(v,t) ffetarget_typeless_hex (v, t)
1281 #define ffetarget_hexzmil(v,t) ffetarget_typeless_hex (v, t)
1282 #define ffetarget_hexzvxt(v,t) ffetarget_typeless_hex (v, t)
1283 #define ffetarget_init_0()
1284 #define ffetarget_init_1()
1285 #define ffetarget_init_2()
1286 #define ffetarget_init_3()
1287 #define ffetarget_init_4()
1288 #ifdef FFETARGET_32bit_longs
1289 #define ffetarget_integerdefault_is_magical(i) \
1290   (((unsigned long int) i) == FFETARGET_integerBIG_MAGICAL)
1291 #else
1292 #define ffetarget_integerdefault_is_magical(i) \
1293   (((unsigned int) i) == FFETARGET_integerBIG_MAGICAL)
1294 #endif
1295 #define ffetarget_iszero_real1(l) \
1296   ({ REAL_VALUE_TYPE lr; \
1297      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1298      REAL_VALUES_EQUAL (lr, dconst0); \
1299    })
1300 #define ffetarget_iszero_real2(l) \
1301   ({ REAL_VALUE_TYPE lr; \
1302      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1303      REAL_VALUES_EQUAL (lr, dconst0); \
1304    })
1305 #define ffetarget_iszero_typeless(l) ((l) == 0)
1306 #define ffetarget_logical1(v,truth) (*(v) = truth ? 1 : 0)
1307 #define ffetarget_le_integer1(res,l,r) \
1308   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
1309 #define ffetarget_le_integer2(res,l,r) \
1310   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
1311 #define ffetarget_le_integer3(res,l,r) \
1312   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
1313 #define ffetarget_le_integer4(res,l,r) \
1314   (*(res) = ((l) <= (r)) ? TRUE : FALSE, FFEBAD)
1315 #define ffetarget_le_real1(res,l,r) \
1316   ({ REAL_VALUE_TYPE lr, rr; \
1317      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1318      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1319      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
1320        ? TRUE : FALSE; \
1321      FFEBAD; })
1322 #define ffetarget_le_real2(res,l,r) \
1323   ({ REAL_VALUE_TYPE lr, rr; \
1324      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1325      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1326      *(res) = (REAL_VALUES_LESS (lr, rr) || REAL_VALUES_EQUAL (lr, rr)) \
1327        ? TRUE : FALSE; \
1328      FFEBAD; })
1329 #define ffetarget_lt_integer1(res,l,r) \
1330   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
1331 #define ffetarget_lt_integer2(res,l,r) \
1332   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
1333 #define ffetarget_lt_integer3(res,l,r) \
1334   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
1335 #define ffetarget_lt_integer4(res,l,r) \
1336   (*(res) = ((l) < (r)) ? TRUE : FALSE, FFEBAD)
1337 #define ffetarget_lt_real1(res,l,r) \
1338   ({ REAL_VALUE_TYPE lr, rr; \
1339      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1340      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1341      *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
1342      FFEBAD; })
1343 #define ffetarget_lt_real2(res,l,r) \
1344   ({ REAL_VALUE_TYPE lr, rr; \
1345      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1346      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1347      *(res) = REAL_VALUES_LESS (lr, rr) ? TRUE : FALSE; \
1348      FFEBAD; })
1349 #define ffetarget_length_character1(c) ((c).length)
1350 #define ffetarget_length_characterdefault ffetarget_length_character1
1351 #define ffetarget_make_real1(res,lr) \
1352   ffetarget_cvt_rv_to_r1_ ((lr), *(res))
1353 #define ffetarget_make_real2(res,lr) \
1354   ffetarget_cvt_rv_to_r2_ ((lr), &((res)->v[0]))
1355 #define ffetarget_multiply_integer1(res,l,r) (*(res) = (l) * (r), FFEBAD)
1356 #define ffetarget_multiply_integer2(res,l,r) (*(res) = (l) * (r), FFEBAD)
1357 #define ffetarget_multiply_integer3(res,l,r) (*(res) = (l) * (r), FFEBAD)
1358 #define ffetarget_multiply_integer4(res,l,r) (*(res) = (l) * (r), FFEBAD)
1359 #define ffetarget_multiply_real1(res,l,r) \
1360   ({ REAL_VALUE_TYPE lr, rr, resr; \
1361      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1362      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1363      REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
1364      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
1365      FFEBAD; })
1366 #define ffetarget_multiply_real2(res,l,r) \
1367   ({ REAL_VALUE_TYPE lr, rr, resr; \
1368      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1369      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1370      REAL_ARITHMETIC (resr, MULT_EXPR, lr, rr); \
1371      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
1372      FFEBAD; })
1373 #define ffetarget_ne_complex1(res,l,r) \
1374   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
1375      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
1376      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
1377      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
1378      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
1379      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
1380        ? FALSE : TRUE; \
1381      FFEBAD; })
1382 #define ffetarget_ne_complex2(res,l,r) \
1383   ({ REAL_VALUE_TYPE lr, li, rr, ri; \
1384      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
1385      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
1386      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
1387      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
1388      *(res) = (REAL_VALUES_EQUAL (lr, rr) && REAL_VALUES_EQUAL (li, ri)) \
1389        ? FALSE : TRUE; \
1390      FFEBAD; })
1391 #define ffetarget_ne_integer1(res,l,r) \
1392   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
1393 #define ffetarget_ne_integer2(res,l,r) \
1394   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
1395 #define ffetarget_ne_integer3(res,l,r) \
1396   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
1397 #define ffetarget_ne_integer4(res,l,r) \
1398   (*(res) = ((l) != (r)) ? TRUE : FALSE, FFEBAD)
1399 #define ffetarget_ne_real1(res,l,r) \
1400   ({ REAL_VALUE_TYPE lr, rr; \
1401      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1402      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1403      *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
1404      FFEBAD; })
1405 #define ffetarget_ne_real2(res,l,r) \
1406   ({ REAL_VALUE_TYPE lr, rr; \
1407      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1408      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1409      *(res) = REAL_VALUES_EQUAL (lr, rr) ? FALSE : TRUE; \
1410      FFEBAD; })
1411 #define ffetarget_neqv_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1412 #define ffetarget_neqv_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1413 #define ffetarget_neqv_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1414 #define ffetarget_neqv_integer4(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1415 #define ffetarget_neqv_logical1(res,l,r) (*(res) = (l) != (r), FFEBAD)
1416 #define ffetarget_neqv_logical2(res,l,r) (*(res) = (l) != (r), FFEBAD)
1417 #define ffetarget_neqv_logical3(res,l,r) (*(res) = (l) != (r), FFEBAD)
1418 #define ffetarget_neqv_logical4(res,l,r) (*(res) = (l) != (r), FFEBAD)
1419 #define ffetarget_not_integer1(res,l) (*(res) = ~(l), FFEBAD)
1420 #define ffetarget_not_integer2(res,l) (*(res) = ~(l), FFEBAD)
1421 #define ffetarget_not_integer3(res,l) (*(res) = ~(l), FFEBAD)
1422 #define ffetarget_not_integer4(res,l) (*(res) = ~(l), FFEBAD)
1423 #define ffetarget_not_logical1(res,l) (*(res) = !(l), FFEBAD)
1424 #define ffetarget_not_logical2(res,l) (*(res) = !(l), FFEBAD)
1425 #define ffetarget_not_logical3(res,l) (*(res) = !(l), FFEBAD)
1426 #define ffetarget_not_logical4(res,l) (*(res) = !(l), FFEBAD)
1427 #define ffetarget_octalmil(v,t) ffetarget_typeless_octal (v, t)
1428 #define ffetarget_octalvxt(v,t) ffetarget_typeless_octal (v, t)
1429 #define ffetarget_offset(res,l) (*(res) = (l), TRUE)    /* Overflow? */
1430 #define ffetarget_offset_add(res,l,r) (*(res) = (l) + (r), TRUE)        /* Overflow? */
1431 #define ffetarget_offset_charsize(res,l,u) (*(res) = (l) * (u), TRUE)   /* Ov? */
1432 #define ffetarget_offset_multiply(res,l,r) (*(res) = (l) * (r), TRUE)   /* Ov? */
1433 #define ffetarget_offset_overflow(text) ((void) 0)      /* ~~no message? */
1434 #define ffetarget_or_integer1(res,l,r) (*(res) = (l) | (r), FFEBAD)
1435 #define ffetarget_or_integer2(res,l,r) (*(res) = (l) | (r), FFEBAD)
1436 #define ffetarget_or_integer3(res,l,r) (*(res) = (l) | (r), FFEBAD)
1437 #define ffetarget_or_integer4(res,l,r) (*(res) = (l) | (r), FFEBAD)
1438 #define ffetarget_or_logical1(res,l,r) (*(res) = (l) || (r), FFEBAD)
1439 #define ffetarget_or_logical2(res,l,r) (*(res) = (l) || (r), FFEBAD)
1440 #define ffetarget_or_logical3(res,l,r) (*(res) = (l) || (r), FFEBAD)
1441 #define ffetarget_or_logical4(res,l,r) (*(res) = (l) || (r), FFEBAD)
1442 #define ffetarget_print_binarymil(f,v) ffetarget_print_binary (f, v)
1443 #define ffetarget_print_binaryvxt(f,v) ffetarget_print_binary (f, v)
1444 #define ffetarget_print_hexxmil(f,v) ffetarget_print_hex (f, v)
1445 #define ffetarget_print_hexxvxt(f,v) ffetarget_print_hex (f, v)
1446 #define ffetarget_print_hexzmil(f,v) ffetarget_print_hex (f, v)
1447 #define ffetarget_print_hexzvxt(f,v) ffetarget_print_hex (f, v)
1448 #define ffetarget_print_integer1(f,v) \
1449   fprintf ((f), "%" ffetargetInteger1_f "d", (v))
1450 #define ffetarget_print_integer2(f,v) \
1451   fprintf ((f), "%" ffetargetInteger2_f "d", (v))
1452 #define ffetarget_print_integer3(f,v) \
1453   fprintf ((f), "%" ffetargetInteger3_f "d", (v))
1454 #define ffetarget_print_integer4(f,v) \
1455   fprintf ((f), "%" ffetargetInteger4_f "d", (v))
1456 #define ffetarget_print_logical1(f,v) \
1457   fprintf ((f), "%" ffetargetLogical1_f "d", (v))
1458 #define ffetarget_print_logical2(f,v) \
1459   fprintf ((f), "%" ffetargetLogical2_f "d", (v))
1460 #define ffetarget_print_logical3(f,v) \
1461   fprintf ((f), "%" ffetargetLogical3_f "d", (v))
1462 #define ffetarget_print_logical4(f,v) \
1463   fprintf ((f), "%" ffetargetLogical4_f "d", (v))
1464 #define ffetarget_print_octalmil(f,v) ffetarget_print_octal(f,v)
1465 #define ffetarget_print_octalvxt(f,v) ffetarget_print_octal(f,v)
1466 #define ffetarget_print_real1(f,l) \
1467   ({ REAL_VALUE_TYPE lr; \
1468      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1469      real_to_decimal (ffetarget_string_, &lr \
1470                          sizeof(ffetarget_string_), 0, 1); \
1471      fputs (ffetarget_string_, (f)); \
1472    })
1473 #define ffetarget_print_real2(f,l) \
1474   ({ REAL_VALUE_TYPE lr; \
1475      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1476      real_to_decimal (ffetarget_string_, &lr, \
1477                          sizeof(ffetarget_string_), 0, 1); \
1478      fputs (ffetarget_string_, (f)); \
1479    })
1480 #define ffetarget_real1_one(res) ffetarget_cvt_rv_to_r1_ (dconst1, *(res))
1481 #define ffetarget_real2_one(res) ffetarget_cvt_rv_to_r2_ (dconst1, &((res)->v[0]))
1482 #define ffetarget_real1_two(res) ffetarget_cvt_rv_to_r1_ (dconst2, *(res))
1483 #define ffetarget_real2_two(res) ffetarget_cvt_rv_to_r2_ (dconst2, &((res)->v[0]))
1484 #define ffetarget_real1_zero(res) ffetarget_cvt_rv_to_r1_ (dconst0, *(res))
1485 #define ffetarget_real2_zero(res) ffetarget_cvt_rv_to_r2_ (dconst0, &((res)->v[0]))
1486 #define ffetarget_size_typeless_binary(t) ((ffetarget_num_digits_(t) + 7) / 8)
1487 #define ffetarget_size_typeless_octal(t) \
1488   ((ffetarget_num_digits_(t) * 3 + 7) / 8)
1489 #define ffetarget_size_typeless_hex(t) ((ffetarget_num_digits_(t) + 1) / 2)
1490 #define ffetarget_subtract_complex1(res,l,r) \
1491   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
1492      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
1493      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
1494      rr = ffetarget_cvt_r1_to_rv_ ((r).real); \
1495      ri = ffetarget_cvt_r1_to_rv_ ((r).imaginary); \
1496      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
1497      REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
1498      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
1499      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
1500      FFEBAD; })
1501 #define ffetarget_subtract_complex2(res,l,r) \
1502   ({ REAL_VALUE_TYPE lr, li, rr, ri, resr, resi; \
1503      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
1504      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
1505      rr = ffetarget_cvt_r2_to_rv_ (&((r).real.v[0])); \
1506      ri = ffetarget_cvt_r2_to_rv_ (&((r).imaginary.v[0])); \
1507      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
1508      REAL_ARITHMETIC (resi, MINUS_EXPR, li, ri); \
1509      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
1510      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
1511      FFEBAD; })
1512 #define ffetarget_subtract_integer1(res,l,r) (*(res) = (l) - (r), FFEBAD)
1513 #define ffetarget_subtract_integer2(res,l,r) (*(res) = (l) - (r), FFEBAD)
1514 #define ffetarget_subtract_integer3(res,l,r) (*(res) = (l) - (r), FFEBAD)
1515 #define ffetarget_subtract_integer4(res,l,r) (*(res) = (l) - (r), FFEBAD)
1516 #define ffetarget_subtract_real1(res,l,r) \
1517   ({ REAL_VALUE_TYPE lr, rr, resr; \
1518      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1519      rr = ffetarget_cvt_r1_to_rv_ ((r)); \
1520      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
1521      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
1522      FFEBAD; })
1523 #define ffetarget_subtract_real2(res,l,r) \
1524   ({ REAL_VALUE_TYPE lr, rr, resr; \
1525      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1526      rr = ffetarget_cvt_r2_to_rv_ (&((r).v[0])); \
1527      REAL_ARITHMETIC (resr, MINUS_EXPR, lr, rr); \
1528      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
1529      FFEBAD; })
1530 #define ffetarget_terminate_0()
1531 #define ffetarget_terminate_1()
1532 #define ffetarget_terminate_2()
1533 #define ffetarget_terminate_3()
1534 #define ffetarget_terminate_4()
1535 #define ffetarget_text_character1(c) ((c).text)
1536 #define ffetarget_text_characterdefault ffetarget_text_character1
1537 #define ffetarget_uminus_complex1(res,l) \
1538   ({ REAL_VALUE_TYPE lr, li, resr, resi; \
1539      lr = ffetarget_cvt_r1_to_rv_ ((l).real); \
1540      li = ffetarget_cvt_r1_to_rv_ ((l).imaginary); \
1541      resr = REAL_VALUE_NEGATE (lr); \
1542      resi = REAL_VALUE_NEGATE (li); \
1543      ffetarget_cvt_rv_to_r1_ (resr, (res)->real); \
1544      ffetarget_cvt_rv_to_r1_ (resi, (res)->imaginary); \
1545      FFEBAD; })
1546 #define ffetarget_uminus_complex2(res,l) \
1547   ({ REAL_VALUE_TYPE lr, li, resr, resi; \
1548      lr = ffetarget_cvt_r2_to_rv_ (&((l).real.v[0])); \
1549      li = ffetarget_cvt_r2_to_rv_ (&((l).imaginary.v[0])); \
1550      resr = REAL_VALUE_NEGATE (lr); \
1551      resi = REAL_VALUE_NEGATE (li); \
1552      ffetarget_cvt_rv_to_r2_ (resr, &((res)->real.v[0])); \
1553      ffetarget_cvt_rv_to_r2_ (resi, &((res)->imaginary.v[0])); \
1554      FFEBAD; })
1555 #define ffetarget_uminus_integer1(res,l) (*(res) = -(l), FFEBAD)
1556 #define ffetarget_uminus_integer2(res,l) (*(res) = -(l), FFEBAD)
1557 #define ffetarget_uminus_integer3(res,l) (*(res) = -(l), FFEBAD)
1558 #define ffetarget_uminus_integer4(res,l) (*(res) = -(l), FFEBAD)
1559 #define ffetarget_uminus_real1(res,l) \
1560   ({ REAL_VALUE_TYPE lr, resr; \
1561      lr = ffetarget_cvt_r1_to_rv_ ((l)); \
1562      resr = REAL_VALUE_NEGATE (lr); \
1563      ffetarget_cvt_rv_to_r1_ (resr, *(res)); \
1564      FFEBAD; })
1565 #define ffetarget_uminus_real2(res,l) \
1566   ({ REAL_VALUE_TYPE lr, resr; \
1567      lr = ffetarget_cvt_r2_to_rv_ (&((l).v[0])); \
1568      resr = REAL_VALUE_NEGATE (lr); \
1569      ffetarget_cvt_rv_to_r2_ (resr, &((res)->v[0])); \
1570      FFEBAD; })
1571 #define ffetarget_value_real1(lr) ffetarget_cvt_r1_to_rv_ ((lr))
1572 #define ffetarget_value_real2(lr) ffetarget_cvt_r2_to_rv_ (&((lr).v[0]))
1573 #define ffetarget_xor_integer1(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1574 #define ffetarget_xor_integer2(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1575 #define ffetarget_xor_integer3(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1576 #define ffetarget_xor_integer4(res,l,r) (*(res) = (l) ^ (r), FFEBAD)
1577 #define ffetarget_xor_logical1(res,l,r) (*(res) = (l) != (r), FFEBAD)
1578 #define ffetarget_xor_logical2(res,l,r) (*(res) = (l) != (r), FFEBAD)
1579 #define ffetarget_xor_logical3(res,l,r) (*(res) = (l) != (r), FFEBAD)
1580 #define ffetarget_xor_logical4(res,l,r) (*(res) = (l) != (r), FFEBAD)
1581
1582 /* End of #include file. */
1583
1584 #endif /* ! GCC_F_TARGET_H */