gcc/f/target.h

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