flang-compiler / f18 Goto Github PK
View Code? Open in Web Editor NEWF18 is a front-end for Fortran intended to replace the existing front-end in the Flang compiler
f18's People
Contributors
Stargazers
Watchers
Forkers
t-bltg austinwells pawosm-arm rouson qicny ibara pjh40 jianpingzeng amckinstry qdzhaov ktras markedz schweitzpgi kiranchandramohan kweide peterwaller-arm ichoyjx tskeith scrasmussen lahlidahlia jdoerfert carolineconcatto davidtruby sameeranjoshi kiranktp levinem clementval adamholm isuruf arjunsuresh1987 richbarton-arm anchu-rajendran saidctb stephenbrodiewild lukeireland1 alexisperry nikhil-mk vjayathirtha-nv pmccormick klausler joker-eph theportlandgroup moneytech cybernetics hattom jeffhammond azurecloudmonk 00mjkf18's Issues
Spurious parse error due to extra space in data statement
In the program below we get this error while parsing:
a.f90:2:12: error: expected '/'
Without the space after the minus sign it is fine.
real :: x(2)
data x /1.0, - 2.0/
end
internal error from Fortran comment on preprocessor directive
Compiling the program below results in this error:
fatal internal error: no case at lib/parser/preprocessor.cc(936)
#if 1 ! Fortran-style comment
#endif
end
missing mandatory blanks in f18 demo
I noticed that the fortran parser is treating most (all?) blanks as optional between adjacent keywords.
The following source code is accepted as valid even though each line with a 'hoops' comment should be illegal:
subroutinefoo(a) ! hoops
class(*) :: a
selecttype (a) ! hoops
typeis (integer) ! hoops
print *, a
typeis (real) ! hoops
print *, a
end select
endsubroutinefoo ! hoops
Reminder: See also p53 table 6.2 "Adjacent keywords where separating blanks are optional" in F2015 standard draft
Confusing parser error for missing POINTER attribute
Compiling this example, the parser emits a bunch of errors because there is no comma after procedure() and the POINTER attribute is required.
type t
procedure() :: p
end type
end
PGI is more helpful. It says: "PROCEDURE component must have the POINTER attribute - p".
Linking failure
The Hollerith unparse implementation needs some static_cast<std::uint64_t> in order to successfully link on Darwin. Here is the diff vs revision 902054b
diff-902054b.diff.txt
More std::string::size_type conversion issues causing build failures
Similar to issue #125, GCC 8.2.0 on Darwin doesn't allow conversions between std::string::size_type and std::uint64_t, and this causes failures in the build of lib/expression. The (incorrectly formatted) diff expr.diff.txt against 451e9e4 fixes the build.
intrinsics-test build failure gcc-8.2/macOS
Trying to link test/evaluate/intrinsics-test on a gcc-8.2/macOS build, I receive a bunch of duplicate symbol errors of the form:
duplicate symbol Fortran::evaluate::ExpressionBase<Fortran::evaluate::Type<(Fortran::common::TypeCategory)0, 1> >::derived() in:
lib/evaluate/libFortranEvaluate.a(expression.cc.o)
lib/evaluate/libFortranEvaluate.a(fold.cc.o)
real-test failures on Power9
I suspect that this is similar to the problems reported in issue #148, but, for completeness, real-test has 480 failures on an IBM Power9 Linux system:
uname: Linux cn2024 4.14.0-49.10.1.el7a.ppc64le #1 SMP Thu Jul 5 17:54:38 UTC 2018 ppc64le ppc64le ppc64le GNU/Linux
GCC 8.2.0: Target: powerpc64le-unknown-linux-gnu
semantic error on correct usage
complex :: ccopy, z
z = ccopy((1.0,2.0))
end
elicits "Use of 'ccopy' as a procedure conflicts with its declaration"
backslash escapes
I would expect the simple program:
program foo
print *, '\'
end program footo compile and print a backslash when executed, which is what happens with no command line options under gfortran and ifort. f18 rejects the program with error: incomplete character literal because backslash escapes are enabled by default. This leads to two questions:
- Should this non-standard behavior be enabled by default?
- Is the "sense" of the command line flags to change this correct? The current behavior is that
-MbackslashDISABLES backslash escapes, and-MnobackslashENABLES them. Doesn't
seem intuitive to me.
As an aside, I'd be happy to generate fixes and pull requests from a fork for little things like this, but I don't know if that fits into your development model or not.
bogus error ("incomplete Hollerith literal") on DO loop with -fparse-only
Trying f18 -fparse-only on http://home.thep.lu.se/~torbjorn/jetset/pythia55.f yields:
f18: could not scan pythia55.f
pythia55.f:14288:14: error: incomplete Hollerith literal
DO 360 HELIX=KLOW,KUPP
^^^^^^^^^^^^^^^
Here's a minimal reproducer:
SUBROUTINE RKBBV
INTEGER HELIX,KLOW,KUPP
DO 360 HELIX=KLOW,KUPP
360 CONTINUE
END
[testing] real-test fails 480 test cases on AArch64 (all of them pass on x86_64)
I've compiled f18 with system-provided gcc/g++ 7.3.0 on similarly configured Gentoo Linux systems, one x86_64, one AArch64. On x86_64, all make test tests are succeeding. On AArch64, one of those tests is failing, which is real-test.
Start 6: Real
6/47 Test #6: Real .............................***Failed 3.49 sec
I've tried to run real-test binary manually. On x86_64 it reports success:
$ ./real-test
all 16805389 tests PASS
On AArch64 it reports 480 failed tests:
$ ./real-test
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x800001 * 0xbf7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x800001 * 0x3f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x80800001 * 0xbf7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x80800001 * 0x3f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbf7ffffe * 0x800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbf7ffffe * 0x80800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3f7ffffe * 0x800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3f7ffffe * 0x80800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1000001 * 0xbefffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1000001 * 0x3efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x81000001 * 0xbefffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x81000001 * 0x3efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1800001 * 0xbe7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1800001 * 0x3e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x81800001 * 0xbe7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x81800001 * 0x3e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbefffffe * 0x1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbefffffe * 0x81000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3efffffe * 0x1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3efffffe * 0x81000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbe7ffffe * 0x1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbe7ffffe * 0x81800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3e7ffffe * 0x1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3e7ffffe * 0x81800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x20000001 * 0x9ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x20000001 * 0x1ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa0000001 * 0x9ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa0000001 * 0x1ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x20800001 * 0x9f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x20800001 * 0x1f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa0800001 * 0x9f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa0800001 * 0x1f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9ffffffe * 0x20000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9ffffffe * 0xa0000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1ffffffe * 0x20000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1ffffffe * 0xa0000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9f7ffffe * 0x20800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9f7ffffe * 0xa0800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1f7ffffe * 0x20800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1f7ffffe * 0xa0800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x21000001 * 0x9efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x21000001 * 0x1efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa1000001 * 0x9efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa1000001 * 0x1efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x21800001 * 0x9e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x21800001 * 0x1e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa1800001 * 0x9e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa1800001 * 0x1e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9efffffe * 0x21000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9efffffe * 0xa1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1efffffe * 0x21000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1efffffe * 0xa1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9e7ffffe * 0x21800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9e7ffffe * 0xa1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1e7ffffe * 0x21800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1e7ffffe * 0xa1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2000001 * 0xbdfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2000001 * 0x3dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x82000001 * 0xbdfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x82000001 * 0x3dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2800001 * 0xbd7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2800001 * 0x3d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x82800001 * 0xbd7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x82800001 * 0x3d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbdfffffe * 0x2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbdfffffe * 0x82000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3dfffffe * 0x2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3dfffffe * 0x82000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbd7ffffe * 0x2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbd7ffffe * 0x82800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3d7ffffe * 0x2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3d7ffffe * 0x82800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3000001 * 0xbcfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3000001 * 0x3cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x83000001 * 0xbcfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x83000001 * 0x3cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3800001 * 0xbc7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3800001 * 0x3c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x83800001 * 0xbc7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x83800001 * 0x3c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbcfffffe * 0x3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbcfffffe * 0x83000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3cfffffe * 0x3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3cfffffe * 0x83000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbc7ffffe * 0x3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbc7ffffe * 0x83800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3c7ffffe * 0x3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3c7ffffe * 0x83800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x22000001 * 0x9dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x22000001 * 0x1dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa2000001 * 0x9dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa2000001 * 0x1dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x22800001 * 0x9d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x22800001 * 0x1d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa2800001 * 0x9d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa2800001 * 0x1d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9dfffffe * 0x22000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9dfffffe * 0xa2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1dfffffe * 0x22000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1dfffffe * 0xa2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9d7ffffe * 0x22800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9d7ffffe * 0xa2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1d7ffffe * 0x22800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1d7ffffe * 0xa2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x23000001 * 0x9cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x23000001 * 0x1cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa3000001 * 0x9cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa3000001 * 0x1cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x23800001 * 0x9c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x23800001 * 0x1c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa3800001 * 0x9c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa3800001 * 0x1c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9cfffffe * 0x23000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9cfffffe * 0xa3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1cfffffe * 0x23000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1cfffffe * 0xa3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9c7ffffe * 0x23800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9c7ffffe * 0xa3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1c7ffffe * 0x23800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1c7ffffe * 0xa3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x10000000000001 * 0xbfeffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x10000000000001 * 0x3feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8010000000000001 * 0xbfeffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8010000000000001 * 0x3feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfeffffffffffffe * 0x10000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfeffffffffffffe * 0x8010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3feffffffffffffe * 0x10000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3feffffffffffffe * 0x8010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x20000000000001 * 0xbfdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x20000000000001 * 0x3fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8020000000000001 * 0xbfdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8020000000000001 * 0x3fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x30000000000001 * 0xbfcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x30000000000001 * 0x3fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8030000000000001 * 0xbfcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8030000000000001 * 0x3fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfdffffffffffffe * 0x20000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfdffffffffffffe * 0x8020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3fdffffffffffffe * 0x20000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3fdffffffffffffe * 0x8020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfcffffffffffffe * 0x30000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfcffffffffffffe * 0x8030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3fcffffffffffffe * 0x30000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3fcffffffffffffe * 0x8030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2000000000000001 * 0x9ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2000000000000001 * 0x1ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa000000000000001 * 0x9ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa000000000000001 * 0x1ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2010000000000001 * 0x9feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2010000000000001 * 0x1feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa010000000000001 * 0x9feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa010000000000001 * 0x1feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9ffffffffffffffe * 0x2000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9ffffffffffffffe * 0xa000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1ffffffffffffffe * 0x2000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1ffffffffffffffe * 0xa000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9feffffffffffffe * 0x2010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9feffffffffffffe * 0xa010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1feffffffffffffe * 0x2010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1feffffffffffffe * 0xa010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2020000000000001 * 0x9fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2020000000000001 * 0x1fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa020000000000001 * 0x9fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa020000000000001 * 0x1fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2030000000000001 * 0x9fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2030000000000001 * 0x1fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa030000000000001 * 0x9fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa030000000000001 * 0x1fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9fdffffffffffffe * 0x2020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9fdffffffffffffe * 0xa020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1fdffffffffffffe * 0x2020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1fdffffffffffffe * 0xa020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9fcffffffffffffe * 0x2030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9fcffffffffffffe * 0xa030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1fcffffffffffffe * 0x2030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1fcffffffffffffe * 0xa030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x40000000000001 * 0xbfbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x40000000000001 * 0x3fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8040000000000001 * 0xbfbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8040000000000001 * 0x3fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x50000000000001 * 0xbfaffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x50000000000001 * 0x3faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8050000000000001 * 0xbfaffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8050000000000001 * 0x3faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfbffffffffffffe * 0x40000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfbffffffffffffe * 0x8040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3fbffffffffffffe * 0x40000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3fbffffffffffffe * 0x8040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfaffffffffffffe * 0x50000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbfaffffffffffffe * 0x8050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3faffffffffffffe * 0x50000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3faffffffffffffe * 0x8050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x60000000000001 * 0xbf9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x60000000000001 * 0x3f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8060000000000001 * 0xbf9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8060000000000001 * 0x3f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x70000000000001 * 0xbf8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x70000000000001 * 0x3f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8070000000000001 * 0xbf8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x8070000000000001 * 0x3f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbf9ffffffffffffe * 0x60000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbf9ffffffffffffe * 0x8060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3f9ffffffffffffe * 0x60000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3f9ffffffffffffe * 0x8060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbf8ffffffffffffe * 0x70000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xbf8ffffffffffffe * 0x8070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3f8ffffffffffffe * 0x70000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x3f8ffffffffffffe * 0x8070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2040000000000001 * 0x9fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2040000000000001 * 0x1fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa040000000000001 * 0x9fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa040000000000001 * 0x1fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2050000000000001 * 0x9faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2050000000000001 * 0x1faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa050000000000001 * 0x9faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa050000000000001 * 0x1faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9fbffffffffffffe * 0x2040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9fbffffffffffffe * 0xa040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1fbffffffffffffe * 0x2040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1fbffffffffffffe * 0xa040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9faffffffffffffe * 0x2050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9faffffffffffffe * 0xa050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1faffffffffffffe * 0x2050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1faffffffffffffe * 0xa050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2060000000000001 * 0x9f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2060000000000001 * 0x1f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa060000000000001 * 0x9f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa060000000000001 * 0x1f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2070000000000001 * 0x9f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x2070000000000001 * 0x1f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa070000000000001 * 0x9f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0xa070000000000001 * 0x1f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9f9ffffffffffffe * 0x2060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9f9ffffffffffffe * 0xa060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1f9ffffffffffffe * 0x2060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1f9ffffffffffffe * 0xa060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9f8ffffffffffffe * 0x2070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x9f8ffffffffffffe * 0xa070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1f8ffffffffffffe * 0x2070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
0 0x1f8ffffffffffffe * 0xa070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x800001 * 0x3f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x80800001 * 0xbf7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbf7ffffe * 0x80800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3f7ffffe * 0x800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1000001 * 0x3efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x81000001 * 0xbefffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1800001 * 0x3e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x81800001 * 0xbe7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbefffffe * 0x81000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3efffffe * 0x1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbe7ffffe * 0x81800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3e7ffffe * 0x1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x20000001 * 0x1ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa0000001 * 0x9ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x20800001 * 0x1f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa0800001 * 0x9f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9ffffffe * 0xa0000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1ffffffe * 0x20000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9f7ffffe * 0xa0800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1f7ffffe * 0x20800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x21000001 * 0x1efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa1000001 * 0x9efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x21800001 * 0x1e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa1800001 * 0x9e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9efffffe * 0xa1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1efffffe * 0x21000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9e7ffffe * 0xa1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1e7ffffe * 0x21800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2000001 * 0x3dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x82000001 * 0xbdfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2800001 * 0x3d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x82800001 * 0xbd7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbdfffffe * 0x82000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3dfffffe * 0x2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbd7ffffe * 0x82800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3d7ffffe * 0x2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3000001 * 0x3cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x83000001 * 0xbcfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3800001 * 0x3c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x83800001 * 0xbc7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbcfffffe * 0x83000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3cfffffe * 0x3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbc7ffffe * 0x83800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3c7ffffe * 0x3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x22000001 * 0x1dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa2000001 * 0x9dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x22800001 * 0x1d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa2800001 * 0x9d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9dfffffe * 0xa2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1dfffffe * 0x22000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9d7ffffe * 0xa2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1d7ffffe * 0x22800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x23000001 * 0x1cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa3000001 * 0x9cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x23800001 * 0x1c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa3800001 * 0x9c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9cfffffe * 0xa3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1cfffffe * 0x23000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9c7ffffe * 0xa3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1c7ffffe * 0x23800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x10000000000001 * 0x3feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8010000000000001 * 0xbfeffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbfeffffffffffffe * 0x8010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3feffffffffffffe * 0x10000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x20000000000001 * 0x3fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8020000000000001 * 0xbfdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x30000000000001 * 0x3fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8030000000000001 * 0xbfcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbfdffffffffffffe * 0x8020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3fdffffffffffffe * 0x20000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbfcffffffffffffe * 0x8030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3fcffffffffffffe * 0x30000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2000000000000001 * 0x1ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa000000000000001 * 0x9ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2010000000000001 * 0x1feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa010000000000001 * 0x9feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9ffffffffffffffe * 0xa000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1ffffffffffffffe * 0x2000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9feffffffffffffe * 0xa010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1feffffffffffffe * 0x2010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2020000000000001 * 0x1fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa020000000000001 * 0x9fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2030000000000001 * 0x1fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa030000000000001 * 0x9fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9fdffffffffffffe * 0xa020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1fdffffffffffffe * 0x2020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9fcffffffffffffe * 0xa030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1fcffffffffffffe * 0x2030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x40000000000001 * 0x3fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8040000000000001 * 0xbfbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x50000000000001 * 0x3faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8050000000000001 * 0xbfaffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbfbffffffffffffe * 0x8040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3fbffffffffffffe * 0x40000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbfaffffffffffffe * 0x8050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3faffffffffffffe * 0x50000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x60000000000001 * 0x3f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8060000000000001 * 0xbf9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x70000000000001 * 0x3f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x8070000000000001 * 0xbf8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbf9ffffffffffffe * 0x8060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3f9ffffffffffffe * 0x60000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xbf8ffffffffffffe * 0x8070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x3f8ffffffffffffe * 0x70000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2040000000000001 * 0x1fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa040000000000001 * 0x9fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2050000000000001 * 0x1faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa050000000000001 * 0x9faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9fbffffffffffffe * 0xa040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1fbffffffffffffe * 0x2040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9faffffffffffffe * 0xa050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1faffffffffffffe * 0x2050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2060000000000001 * 0x1f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa060000000000001 * 0x9f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x2070000000000001 * 0x1f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0xa070000000000001 * 0x9f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9f9ffffffffffffe * 0xa060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1f9ffffffffffffe * 0x2060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x9f8ffffffffffffe * 0xa070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
2 0x1f8ffffffffffffe * 0x2070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x800001 * 0xbf7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x80800001 * 0x3f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbf7ffffe * 0x800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3f7ffffe * 0x80800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1000001 * 0xbefffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x81000001 * 0x3efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1800001 * 0xbe7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x81800001 * 0x3e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbefffffe * 0x1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3efffffe * 0x81000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbe7ffffe * 0x1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3e7ffffe * 0x81800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x20000001 * 0x9ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa0000001 * 0x1ffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x20800001 * 0x9f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa0800001 * 0x1f7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9ffffffe * 0x20000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1ffffffe * 0xa0000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9f7ffffe * 0x20800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1f7ffffe * 0xa0800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x21000001 * 0x9efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa1000001 * 0x1efffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x21800001 * 0x9e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa1800001 * 0x1e7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9efffffe * 0x21000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1efffffe * 0xa1000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9e7ffffe * 0x21800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1e7ffffe * 0xa1800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2000001 * 0xbdfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x82000001 * 0x3dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2800001 * 0xbd7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x82800001 * 0x3d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbdfffffe * 0x2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3dfffffe * 0x82000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbd7ffffe * 0x2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3d7ffffe * 0x82800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3000001 * 0xbcfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x83000001 * 0x3cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3800001 * 0xbc7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x83800001 * 0x3c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbcfffffe * 0x3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3cfffffe * 0x83000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbc7ffffe * 0x3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3c7ffffe * 0x83800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x22000001 * 0x9dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa2000001 * 0x1dfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x22800001 * 0x9d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa2800001 * 0x1d7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9dfffffe * 0x22000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1dfffffe * 0xa2000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9d7ffffe * 0x22800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1d7ffffe * 0xa2800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x23000001 * 0x9cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa3000001 * 0x1cfffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x23800001 * 0x9c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa3800001 * 0x1c7ffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9cfffffe * 0x23000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1cfffffe * 0xa3000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9c7ffffe * 0x23800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1c7ffffe * 0xa3800001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x10000000000001 * 0xbfeffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8010000000000001 * 0x3feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbfeffffffffffffe * 0x10000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3feffffffffffffe * 0x8010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x20000000000001 * 0xbfdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8020000000000001 * 0x3fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x30000000000001 * 0xbfcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8030000000000001 * 0x3fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbfdffffffffffffe * 0x20000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3fdffffffffffffe * 0x8020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbfcffffffffffffe * 0x30000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3fcffffffffffffe * 0x8030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2000000000000001 * 0x9ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa000000000000001 * 0x1ffffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2010000000000001 * 0x9feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa010000000000001 * 0x1feffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9ffffffffffffffe * 0x2000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1ffffffffffffffe * 0xa000000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9feffffffffffffe * 0x2010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1feffffffffffffe * 0xa010000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2020000000000001 * 0x9fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa020000000000001 * 0x1fdffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2030000000000001 * 0x9fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa030000000000001 * 0x1fcffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9fdffffffffffffe * 0x2020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1fdffffffffffffe * 0xa020000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9fcffffffffffffe * 0x2030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1fcffffffffffffe * 0xa030000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x40000000000001 * 0xbfbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8040000000000001 * 0x3fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x50000000000001 * 0xbfaffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8050000000000001 * 0x3faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbfbffffffffffffe * 0x40000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3fbffffffffffffe * 0x8040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbfaffffffffffffe * 0x50000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3faffffffffffffe * 0x8050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x60000000000001 * 0xbf9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8060000000000001 * 0x3f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x70000000000001 * 0xbf8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x8070000000000001 * 0x3f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbf9ffffffffffffe * 0x60000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3f9ffffffffffffe * 0x8060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xbf8ffffffffffffe * 0x70000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x3f8ffffffffffffe * 0x8070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2040000000000001 * 0x9fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa040000000000001 * 0x1fbffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2050000000000001 * 0x9faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa050000000000001 * 0x1faffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9fbffffffffffffe * 0x2040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1fbffffffffffffe * 0xa040000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9faffffffffffffe * 0x2050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1faffffffffffffe * 0xa050000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2060000000000001 * 0x9f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa060000000000001 * 0x1f9ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x2070000000000001 * 0x9f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0xa070000000000001 * 0x1f8ffffffffffffe
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9f9ffffffffffffe * 0x2060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1f9ffffffffffffe * 0xa060000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x9f8ffffffffffffe * 0x2070000000000001
real.cc:345: FAIL: FlagsToBits(prod.flags) == 0x10, not 0x18
3 0x1f8ffffffffffffe * 0xa070000000000001
16804909 tests pass, 480 tests FAIL
Parser need to provide precise token location to the parse tree
The current f18 parser does not appear to provide any accurate information about the tokens (location, length, ...). The purpose of this ticket is to
- explain why this is needed
- figure out a proper strategy to obtain the required information
- track the implementation progress
A fundamental property of the Clang AST is that each node must be able to provide SourceLocation for its first and last tokens and in some cases for other intermediate tokens. In C/C++, the tokenization is basically context free so it is always possible to recreate a token from its SourceLocation. That feature is used extensively for instance to find the length of each token and so the exact location of its last character. Eventually, the start and end SourceLocation will be used to build accurate character ranges that will themselves be used to implement code rewrite in the original source code (Refactoring).
Simply speaking, accurate SourceLocation at the token level is absolutely critical for Clang tooling and also for good diagnostics.
In Fortran, the implementation will be significantly different because the tokenization process is highly dependent of the context. In practice, that means that providing a SourceLocation per token will not be sufficient unless additional information are also provided (length of the token, ...). The actual length of the token will also be needed. An alternative could be to track the start and end SourceLocation of each token separately and to store whatever information is needed.
I am bit concerned because I do not see any obvious way to track that information in the current parser. One issue is that the '>>' and '/' operators can only propagate information from either the left or right parser.
To illustrate my point, let's consider a very simple rule:
// R849 intent-stmt -> INTENT ( intent-spec ) [::] dummy-arg-name-list
TYPE_CONTEXT_PARSER("INTENT statement",
"INTENT" >> construct<IntentStmt>{}(
parenthesized(intentSpec) / maybe("::"_tok),
nonemptyList(name)
)
)
There are 4 tokens in that rule and most of them are relevant for Tooling. For example:
- "INTENT" because a style checker may want to insure that all keywords are lowercase.
- "::" because a style checker may want to insure that all optional "::" are present
- ")" because in the final AST, it is likely that "INTENT(intent-spec)" will get its own AST (also used in other declaration statements). That means that ")" becomes the last token for that node and that its location must be provided (see above). For the same reason, the "INTENT" token should also be tracked.
I guess that the relevant token locations could be passed to the IntentStmt constructor by rewriting the parsing rule into something like that:
// R849 intent-stmt -> INTENT ( intent-spec ) [::] dummy-arg-name-list
TYPE_CONTEXT_PARSER("INTENT statement",
construct<IntentStmt>{}(
"INTENT"_tok,
"(" >> intentSpec,
")"_tok,
maybe("::"_tok),
nonemptyList(name)
)
)
Rewriting the full parser like that would be quite painful. We probably want something less intrusive.
An alternative way of handling tokens could be to store all matched tokens in a global data structure with the capability to explore the sequence of tokens. For the given example, the IntentSpec rule could store the location of its unique token (IN, OUT, or INOUT) and IntentStmt could use that token location to infer the location of its own token. That method minimizes the number of token locations that have to be passed to the constructors of the parse tree.
Why f18 looks for pgf90?
This is in continuation to issue #285 .
When f18 is used to compile a Fortran program to create "a.out", the below message is generated:
The below error is generated:
#f18 test.f90
execvp(pgf90) failed: No such file or directory
Please help me understand the issue and an appropriate solution to the issue.
I am a new newbie to f18, I don't know why pgf90 (PG Fortran) is invoked by f18.
Thanks in anticipation!
Legacy extension conflicts with modern Fortran
PGI and other Fortran compilers support the abbreviated notations .N., .A., .O., and .X. for the logical operators .NOT., .AND., .OR., and the extension .XOR..
These names can conflict with the use of defined operators with the same names.
These operators have distinct precedences from that of defined operators (defined unary operators bind more tightly, defined binary operators bind least tightly), so we can't just treat them as some kind of predefined defined operator.
There's also .T. and .F. abbreviations for .TRUE. and .FALSE. (resp.), and those can also conflict with defined operators.
We may need to add a parsing option to enable these cases, or disable them in standard compliant mode. Not sure what the default should be.
test script portability issues
When trying to run the tests on a macOS system, I ran into several bash script compatibility problems. I've attached a diff file relative to 94c1f72 that I believe should work on Linux and macOS. Here is a summary of the problems and how I addressed them:
- bash is at
/bin/bashon macOS systems rather than/usr/bin/bash. I moved to/usr/bin/env bashat the top of each script. - the
rmcommand is in/binon macOS, so I added that to the PATH mktemptakes a completely different argument set. I can't emulate the behavior of creating a temp directory under"./", so I made it under TMPDIR for both cases.- the regular expression library on macOS is stricter on compliance with IEEE Std 1003.2, so in basic re mode, sed does not recognize
'\t'as a TAB character. This caused the "$expect" string extraction to fail. I replaced'\t'with'.', which is a little weaker of a match.
With these changes, all tests run successfully.
diff file:
script.diff.txt
Issue with leading semicolon in free-format
Given an input of:
subroutine foo
; call bar
end subroutine
f18 is reporting
semi.f90:2:3: error: expected 'TYPE'
; call bar
^
semi.f90:2:3: in the context: TYPE statement
semi.f90:2:3: in the context: derived type definition
semi.f90:2:3: in the context: specification construct
semi.f90:2:3: in the context: declaration construct
semi.f90:2:3: in the context: specification part
semi.f90:1:1: in the context: SUBROUTINE subprogram
subroutine foo
It would appear that the parsers are being fed an empty statement and they don't know what to do with it. While the standard is clear that it is illegal to have a semicolon as the first non-blank character in an initial fixed format line [6.3.3.4-2], it is less clear for free form. Given that repeated semicolons/spaces are equivalent to a single semicolon [6.3.2.5-2], I read that to mean that empty statements are ignored, and that rule should apply to the initial semicolon as well. ifort and gfortran agree with this interpretation. Regardless of wether you wish to support the empty initial statement or not, the error message is incorrect.
std::string::size_type causing problems on Mac gcc-8.1.0
Under gcc-8.1.0 (or libstdc++-8.1.0 to be more specific), the std::string::size_type is 'unsigned long'. This causes compilation errors with the instantiation of
template<int KIND>
typename CharacterExpr<KIND>::LengthExpr CharacterExpr<KIND>::LEN() const;at expression.cc:211, because there is no Integer(unsigned long) ctor, and g++ is reluctant to convert UL to ULL. This can be addressed with a std::uint64_t(x.size()) in the base case of the visitor constructor, or, perhaps more robustly, adding Integer(unsigned long).
parsing of line labels in Format
Format is declared as
struct Format {
UNION_CLASS_BOILERPLATE(Format);
std::variant<DefaultCharExpr, Label, Star> u;
};
With an input such as
write (*,60) "Hello, World"
60 format (A)
end
It appears that the parser is returning a Format that holds IntLiteralConstant->LiteralConstant with the value 60 rather than a Label 60.
Make warnings and errors more like clang
clang's diagnostics have the format (where <severity> is "error" or "warning"):
<source-file>:<line>:<column>: <severity>: <message>
These are followed by the line of source and a caret line that look identical to what we are already producing.
They are can be preceded by context like:
<source-file>: In member function '...':
Compilation failure on macOS
Integer::HUGE()collides with macroHUGEinmath.h- Requires casting in
UnparseVisitor::Before(const HollerithLiteralConstant &x)(See #158)
valgrind error during parsing
Running valgrind f18 -funparse a.f90 on this source results in "Conditional jump or move depends on uninitialised value(s)" errors.
subroutine s
integer :: foo
contains
subroutine bar
end
end
It still produces the correct output.
Entities vs EXTERNAL vs PROCEDURE
The purpose of this ticket is to discuss the implementation of the EXTERNAL attribute and the new PROCEDURE( ) declaration statement.
First a bit of history: In early Fortran, calling an external function was easy. You would simply declare its non-array return type and use it as a function:
integer foo
print *, foo(42)
The entity foo was known to be a function by its usage.
Of course, using a declared entity as a function and as variable is not possible:
integer foo, bar
print *, bar ! bar is now a variable
print *, foo(42) ! legal: foo is now external
print *, bar(42) ! illegal: bar was previously used as a variable
So the first consequence of this behavior is that we need to track the use of each entity (local declaration and dummy arguments) that is susceptible to gain the EXTERNAL attribute. I propose to add a new attribute VARIABLE that should initially be false and that that will be set to true once the entity is used as a variable.
At that point, an EXTERNAL attribute was introduced to allow external procedures to be passed as arguments.
integer foo, val
external foo
call bar(foo,val) ! foo is an external while val is a variable
...
subroutine bar(fun)
integer fun, val
print *, fun(val)
end
We see here that the dummy argument 'fun' gained the EXTERNAL attribute.
In modern Fortran a new syntax was introduced to declare PROCEDURE entities.
For instance, the following is strictly equivalent to INTEGER, EXTERNAL :
procedure(integer) :: foo
- PROCEDURE() can also take a procedure name as argument to specify a full prototype instead of a return type.
- a PROCEDURE() entity can have the POINTER attribute.
The current implementation is still incomplete but
- In ResolveNamesVisitor::Post(const parser::SubroutineStmt &stmt), all dummy arguments symbols are immediately given EntityDetails
- In Post(const parser::ProcedureDesignator &x), symbols without 'details' are given SubprogramDetails.
Also, when given explicitly, the EXTERNAL attribute appears to be treated like any other attributes.
I am proposing something slightly different:
-
add a new Procedure category to DeclTypeSpec with two variants: one that provides only a return type and one that provides a Symbol with SubprogramDetails
-
An entity declared explicitly with PROCEDURE(xxxx) shall be associated to a Symbol with EntityDetails and a DeclTypeSpec of category Procedure(xxxx).
-
when an entity is given the EXTERNAL attribute (either explicitly or by usage), its symbol should be given EntityDetails (if this is not already the case) and its type should be changed from 'oldtype' to 'Procedure(oldtype)'
-
For each subroutine or function construct, the associated Symbol 'name' should be given SubprogramDetails. Querying the type of that symbol shall return a DeclTypeSpec of category Procedure(name).
To summarize, I propose to encode 'external' and procedure() in the symbol type instead of using an attribute.
Master broken: Label tests loop
The tests in test/semantics/label{01,05,06,07}.[fF]90 cause f18 as built from the current master branch (at least with gcc-8.2.0 on x86) to loop indefinitely.
unparse produces improper Hollerith
-funparse is not emitting the character count preceding a Hollerith constant:
subroutine foo()
implicit none
integer*4 a
a=4habcd
end
produces
SUBROUTINE foo
IMPLICIT NONE
INTEGER*4 a
a = Habcd
END SUBROUTINE
Extended derived types can't access ancestor members
program main
type ::t1
integer :: t1mem
end type t1
type, extends(t1) :: t2
integer :: t2mem
end type t2
type(t2) :: x2
print *, x2%t1mem
end program main
elicits
../../test/component.f90:9:15: error: Component 't1mem' not found in derived type 't2'
print *, x2%t1mem
^^^^^
../../test/component.f90:5:24: Declaration of 't2'
type, extends(t1) :: t2
^^
Conversion of Denormal floating-point values gives unexpected results
The issue occurs both when going from and to denormal values in lib/evaluate/real.h Convert function.
Going from a value that is not denormal in a type towards a less precise type where the value is denormal gives unexpected result. The conversion should right shift the significant.
Suspected Root Cause:
It seems The Normalize function is not handling negative exponents. They are going through case else if (lshift == 0) line 283 and the new exponent is set to 1 without any shifts. However, maybe it should be up to the caller of Normalize to handle negative exponent up-front, not sure.
Code reproducing the issue:
#include "../../lib/evaluate/type.h"
#include <iostream>
using FROM = Real<Integer<32>, 24>;
using TO = Real<Integer<64>, 53>;
FROM x32{typename FROM::Word{std::uint64_t{8}}};
ValueWithRealFlags<TO> x64{TO::Convert(x32)};
ValueWithRealFlags<FROM> xx32{FROM::Convert(x64.value)}; //converting non denormal toward denormal
auto hx{*reinterpret_cast<float*>(&x32)};
auto hxx{*reinterpret_cast<float*>(&xx32)};
std::cout<<"expected: "<<hx<<" result: "<<hxx<<std::endl; //should be identical
Current output for me is "expected: 1.12104e-44 result: 1.17549e-38".
Recursive PDTs don't work yet
The implementation of PDTs needs to be rearranged a little so that the type name and type parameters are visible for use in the definitions of components within the derived type definition.
[QUESTION] Why GCC headers
This might be trivial to answer for the core devs but I am curious why use GNU headers for a project targeting LLVM and libc?
What features does glibc provide that are not or cannot be implemented with libc?
CMake could not find ClangTargets.cmake
The "LLVM and clang Dependency" section of the f18 README.md file provides a link to directions for building clang and LLVM from source. Does building f18 require building clang and LLVM from source? I tried building clang and llvm using package management on Ubuntu 18.04:
sudo apt install clang llvm
but I'm not sure how to set Clang_DIR. I tried following:
$ export Clang_DIR=/usr/share/llvm-6.0/cmake/
$ git clone https://github.com/flang-compiler/f18
Cloning into 'f18'...
remote: Counting objects: 6799, done.
remote: Compressing objects: 100% (186/186), done.
remote: Total 6799 (delta 236), reused 292 (delta 189), pack-reused 6424
Receiving objects: 100% (6799/6799), 2.47 MiB | 13.55 MiB/s, done.
Resolving deltas: 100% (4839/4839), done.
$ mkdir -p f18/build
$ cd f18/build
$ cmake ..
-- The CXX compiler identification is GNU 7.3.0
-- Check for working CXX compiler: /usr/bin/g++
-- Check for working CXX compiler: /usr/bin/g++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Build Type: Debug
CMake Error at /usr/share/llvm-6.0/cmake/ClangConfig.cmake:18 (include):
include could not find load file:
/usr/lib/cmake/clang/ClangTargets.cmake
Call Stack (most recent call first):
CMakeLists.txt:42 (find_package)
-- Found Clang in /usr
-- Found LLVM 6.0.0
-- Using LLVMConfig.cmake in: /usr/lib/llvm-6.0/cmake
-- FLANG version: 0.1.0
-- Configuring incomplete, errors occurred!
See also "/home/rouson/Desktop/f18/build/CMakeFiles/CMakeOutput.log".
The CMakeOutput.log is attached. I'm not sure whey cmake is looking in /usr/lib/cmake/clang/ (which does not exist) to find ClangTargets.cmake, which is actually in the path defined in $Clang_DIR.
I also tried building clang and llvm from source using the directions provided at the link in the same section of the f18 README.md. Steps 1 to 6 of 10 worked, but the make in step 7 fails due to numerous undefined symbols.
Out-of-context Hollerith constant parsing masks proper syntax error reporting
The resolution for issue #152 fixes the particular case of Holleriths in a LABEL-DO-STMT, but it doesn't address a more general problem, which is that Hollerith constants are being accepted in contexts outside of where they are expected. This causes problems with syntax error reporting. For example, a mangled computed goto statement:
subroutine foo(hin,IOUT)
integer hin
iout=0
goto (100 hin-6
iout=1
100 iout=iout+1
end
results in f18 generating an incomplete Hollerith error, rather than a syntax error for a computed goto statement. This is confusing, since Hollerith constants should not be expected in this context. As an example of a (seemingly generous) scope for Hollerith constants,
GNU Fortran supports Hollerith constants in assignments, function arguments, and DATA and ASSIGN statements.
It seems that we need different productions that introduce a scope where Hollerith constants are allowed so that they don't get misdiagnosed in other contexts. I don't have a language standard that
describes a grammar with Hollerith constants, but I believe that it can be found in an appendix to the F77 standard.
One final note. If there is a desire at some point to create an option for strict standards compliance (e.g. -std=f08), there needs to be ways of allowing/disabling Holleriths in different contexts: as above for F66 or F77 with extensions, FORMAT edit descriptors through F90, none past then. We find pedantic standards enforcement to be useful for code portability. I'm guessing that there is already a mechanism in the parsing routines to convert between accept, warn or error depending on runtime flags, but I don't know how to employ it.
Bad call to memcpy when source has carriage returns
If you run valgrind f18 -fparse-only a.f90 where a.f90 contains carriage returns, it reports:
Source and destination overlap in memcpy(0x4023000, 0x4023000, 3)
at 0x4C2E04C: memcpy@@GLIBC_2.14 (vg_replace_strmem.c:1022)
by 0x8B7CE8: Fortran::parser::RemoveCarriageReturns(char*, unsigned long) (source.cc:93)
It seems to work okay, but the behavior of memcpy is undefined when the source and destination overlap. And it would be nice to be able to run cleanly with valgrind.
Conversion of Real from lower to higher precision gives unexpected results
Calling lib/evaluate/real.h function Convert with an argument from a less precise type gives wrong result.
template<typename A> static ValueWithRealFlags<Real> Convert(
const A &x, Rounding rounding = defaultRounding)
Suspected Root Cause:
line 284: Fraction fraction{Fraction::ConvertUnsigned(xFraction).value}; should be right shifted by -bitsLost so that the MSB of the old value remains the MSB of the new value.
Code reproducing the issue
#include "../../lib/evaluate/type.h"
#include <iostream>
using namespace Fortran::evaluate::value;
float x{0.5f};
auto rx{*reinterpret_cast<Real<Integer<32>, 24>*>(&x)};
auto ry{Real<Integer<64>, 53>::Convert(rx).value}; //issue here
auto y{*reinterpret_cast<double*>(&ry)};
std::cout<<"expected: "<<x<<" result: "<<y<<std::endl; //should be identical
Currently, the output for me is "expected: 0.5 result: 9.31323e-10"
Error recovery: executable construct in module
For this example:
module m
i = 1
end
the parse reports this error:
a.f90:1:8: error: expected '('
module m
^
a.f90:1:1: in the context: statement function definition
module m
^
This could be especially confusing because even with declarations before the assignment the error seems to be the same. So the error message can be pointing a long way from where the error occurs.
IMPLICIT NONE is not inherited by nested scope
In the example below, the compiler should report an error on the use of x:
program test
implicit none
contains
subroutine foo
x = 666 ! wrong since x has no implicit rule
end subroutine
end program
Support unique identifiers for warnings
To be compatible with clang, we need identifiers for each warning. clang emits them in warning messages. For example:
test.cc:2:7: warning: unused variable 'bar' [-Wunused-variable]
These identifiers can be used in options to enable specific warnings (clang -Wunused-variable), to promote them to errors (clang -Werror=unused-variable), or to demote them back to warnings (clang -Wall -Werror -Wno-error=unused-variable).
We will probably need to do all those things. Also, we will want a collection of warnings that get promoted to errors when we are in a mode for strict standard compliance.
Currently the Message class has an isFatal property. We could replace that with an optional warning identifier, so fatal errors would be distinguished by not having one. The API for creating a Message would have the option of providing the identifier. Given that, I don’t think we need separate _en_US and _err_en_US user-defined literals, which I think is good because the latter is kind of unwieldy.
The warning identifiers have to remain stable over time, even if the text of the message changes (or is even translated). Once a user can use it in a -W option we need to keep it working.
Document potential runtime checks
Create a document to track runtime checks that flang might implement.
- Check that assignments to entities with the contiguous attribute are indeed contiguous.
- Check that a pointer is not null or uninitialized before it is used.
- Check for stack overflow.
Build fails on gcc-8.1.0
Hi --
I began getting build failures with gcc-8.1.0. Building the latest (16ed602) results in:
[1/53] 8g++ -I../include -Iinclude -I/usr/local/include -std=c++17 -Wall -pedantic -O2 -DDEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -MD -MT test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o -MF test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o.d -o test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o -c ../test/evaluate/integer.cc
FAILED: test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o
8g++ -I../include -Iinclude -I/usr/local/include -std=c++17 -Wall -pedantic -O2 -DDEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -MD -MT test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o -MF test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o.d -o test/evaluate/CMakeFiles/integer-test.dir/integer.cc.o -c ../test/evaluate/integer.cc
In file included from ../test/evaluate/integer.cc:16:
../test/evaluate/integer.cc: In function 'int main()':
../test/evaluate/integer.cc:265:38: error: call of overloaded 'Integer(<brace-enclosed initializer list>)' is ambiguous
TEST(Integer<128>{0x123456789abcdef}.Hexadecimal() == "123456789abcdef");
^
../test/evaluate/testing.h:31:50: note: in definition of macro 'TEST'
testing::Test(__FILE__, __LINE__, #predicate, (predicate))
^~~~~~~~~
In file included from ../test/evaluate/integer.cc:15:
../test/evaluate/../../lib/evaluate/integer.h:130:13: note: candidate: 'constexpr Fortran::evaluate::value::Integer<BITS, IS_LITTLE_ENDIAN, PARTBITS, PART, BIGPART>::Integer(int) [with int BITS = 128; bool IS_LITTLE_ENDIAN = true; int PARTBITS = 32; PART = unsigned int; BIGPART = long long unsigned int]'
constexpr Integer(int ni) {
^~~~~~~
../test/evaluate/../../lib/evaluate/integer.h:117:13: note: candidate: 'constexpr Fortran::evaluate::value::Integer<BITS, IS_LITTLE_ENDIAN, PARTBITS, PART, BIGPART>::Integer(int64_t) [with int BITS = 128; bool IS_LITTLE_ENDIAN = true; int PARTBITS = 32; PART = unsigned int; BIGPART = long long unsigned int; int64_t = long long int]'
constexpr Integer(std::int64_t n) {
^~~~~~~
../test/evaluate/../../lib/evaluate/integer.h:106:13: note: candidate: 'constexpr Fortran::evaluate::value::Integer<BITS, IS_LITTLE_ENDIAN, PARTBITS, PART, BIGPART>::Integer(uint64_t) [with int BITS = 128; bool IS_LITTLE_ENDIAN = true; int PARTBITS = 32; PART = unsigned int; BIGPART = long long unsigned int; uint64_t = long long unsigned int]'
constexpr Integer(std::uint64_t n) {
^~~~~~~
../test/evaluate/../../lib/evaluate/integer.h:105:13: note: candidate: 'constexpr Fortran::evaluate::value::Integer<BITS, IS_LITTLE_ENDIAN, PARTBITS, PART, BIGPART>::Integer(const Fortran::evaluate::value::Integer<BITS, IS_LITTLE_ENDIAN, PARTBITS, PART, BIGPART>&) [with int BITS = 128; bool IS_LITTLE_ENDIAN = true; int PARTBITS = 32; PART = unsigned int; BIGPART = long long unsigned int]'
constexpr Integer(const Integer &) = default;
^~~~~~~
ninja: build stopped: subcommand failed.
The last verified commit I can build is f21c334.
Thanks!
Label resolution failure
Compiling f90_correct/check_mod.f90 with semantic analysis enabled exposes what seems to be a bug in label resolution that elicits bogus error messages like
/proj/ta/tests/f90_correct/check_mod.f90:581:13: label '100' is not in scope
goto 100
^^^^^^^^
/proj/ta/tests/f90_correct/check_mod.f90:595:11: label '100' is not in scope
if (abserror .gt. dabs(atoler)) goto 100
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
/proj/ta/tests/f90_correct/check_mod.f90:600:11: label '100' is not in scope
if (relerror .gt. dabs(rtoler)) goto 100
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
/proj/ta/tests/f90_correct/check_mod.f90:604:11: label '100' is not in scope
if (ulperror(reslt(i),expct(i)) .gt. dabs(ulptoler)) goto 100
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
/proj/ta/tests/f90_correct/check_mod.f90:615:3: error: label '100' is not distinct
100 tests_failed = tests_failed + 1 ! No tolerances, here we've failed
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Restrictions for exit statement not handled in do concurrent semantic checks
Restrictions for exit statement is not handled in do concurrent semantic checks.
C1167 states that an exit statement shall not appear in a "do concurrent" construct if it belongs to that construct or an outer construct.
For e.g : the exit from do concurrent via exit mydoc in the following example should not be allowed. While Flang catches this, F18 does not.
subroutine run_par(n)
mydoc: do concurrent(j=1:n)
mydo: do k=1,n
If (k==5) exit mydoc
If (j==10) exit mydo
end do mydo
end do mydoc
end subroutine
I have the following questions,
-> Is the plan to cover this in the semantics for exit statement?
-> Are you currently working on this?
-> Would this be a well-defined work for me or my colleagues to get started with F18?
Question: parse tree element provenance
Just a question, not an issue. Is there a mechanism to lookup the CharBlock or ProvenanceRange for any element in the parse tree? For leaf/terminals this would be the lexeme, and for interior nodes it would be the union of the ranges below.
Potential problem with CookedSource::GetProvenanceRange
I had some unexpected behavior from CookedSource::GetProvenanceRange, but I don't know if it is doing what you expect or not. I assumed that, given a CharBlock identified by the parsers, this would return a ProvenanceRange that mapped all of the cooked CharBlock characters back to the original input source. The way it is implemented now, the returned ProvenanceRange starts where I would expect, but extends only to the:
- end of the
provenanceMap_range that contains it, or - size of the
cookedRangeargument.
Option 1 is unexpected, because it tends to truncate statements that span multiple provenanceMap_ ranges. Option 2 is unexpected because the cookedRange has had the spaces baked out of it already, so the resultant ProvenanceRange may be much smaller than it should be.
Just to express the intended behavior, I reimplemented that function as:
ProvenanceRange CookedSource::GetProvenanceRange(CharBlock cookedRange) const {
ProvenanceRange range1{provenanceMap_.Map(cookedRange.begin() - &data_[0])};
ProvenanceRange range2{provenanceMap_.Map(cookedRange.end() - &data_[0])};
return {range1.start(), range2.start() - range1.start()};
}which does work the way I expected it to. Of course, this is doing a lot of unnecessary work forming ranges that we are discarding, but I was just trying to be as clear and concise as possible.
If I'm misinterpreting the intent of this function, would it be possible to add one that acts the way that I described? Or is it already there and I've missed it?
Thanks again!
About F18 integration with LLVM (**Query**)
Hello,
This is in continuation to my query, logged as issue #290.
I have some more queries (these are not issues) about f18:
- Is there any tentative timeline by which f18 would be integrated with LLVM? As we know, the f18 currently uses PG Fortran for compilation of a program.
- Is there any other dedicated forum/distribution list etc. where we can get all the latest information/update about work being done in f18?
Regards.
Internal error parsing incomplete module
Compiling a source file containing the single line module m, I get this:
fatal internal error: CHECK(!parseState.anyErrorRecovery() || parseState.messages().AnyFatalError()) failed at lib/parser/parsing.cc(106)
How to use f18 compiler for fortran?
Hello,
I was trying to build and use f18 compiler for Fortran. I have run steps to build llvm-clang and f18 as mentioned on the below URL:
https://github.com/flang-compiler/f18
All the steps mentioned here are successfully executed. But, I am not able to use f18 compiler.
I am trying to compile a Fortran program test.f90 as follows:
f18 test.f90
But it does not work and I get the below error:
f18: command not found...
Please guide.
PS:
I don't have flang installed on my system.
Thanks in anticipation!
%RE and %IM complex part access
These are parsed as component accesses and then failing in semantics as references to components of something that is not a derived type. They should be silently passed through name resolution so that expression semantic analysis can take care of them, I think.
Errors reported when compiling OpenCoarrays
The source code repository is
https://github.com/sourceryinstitute/OpenCoarrays.git
For example:
./src/tests/integration/pde_solvers/coarrayHeatSimplified/global_field.f90:102:73: error: expected ')'
local_laplacian(1)=(rhs%values(2)-2.*rhs%values(1)+rhs%values(N)[me-1])/dx**2
^
f18 can't be build with -DBUILD_SHARED_LIBS=True
For some reason, libFortranParser.so is not used to build final executable binary, causing linker to complain about missing Fortran::parser::QuoteCharacterLiteral symbol exported by libFortranParser.so.
GetScalarConstantValue returns nullptr for constant Expr<SomType> and Expr<SomeKind<CAT>>
Scalar<T>* GetScalarConstantValue from https://github.com/flang-compiler/f18/blob/master/lib/evaluate/fold.h is always returning nullptr for Expr<SomType> and Expr<SomeKind<CAT>> arguments even when they are scalar constants.
GetScalarConstantValue is working as expected for Expr<Type<Category, kind>> arguments.
The suspected root cause is the use of UnwrapExpr<Expr<T>>(expr.u) instead of UnwrapExpr<Expr<T>>(expr) in the overloads of GetScalarConstantValue related to Expr<SomType> and Expr<SomeKind<CAT>>.
Smallest program illustrating the issue:
#include "../../lib/evaluate/fold.h"
#include "../../lib/evaluate/expression.h"
#include <cstdio>
int main() {
using namespace Fortran::evaluate;
using Int4 = Type<TypeCategory::Integer, 4>;
Expr<Int4> exprInt4{Expr<Int4>{Constant<Int4>{Scalar<Int4>{}}}};
Expr<SomeInteger> exprSomeInt{exprInt4};
Expr<SomeType> exprSomeType{exprSomeInt};
std::printf("exprInt4: %s\n", GetScalarConstantValue<Int4>(exprInt4)? "OK" : "BUG?");
std::printf("exprSomeInt: %s\n", GetScalarConstantValue<Int4>(exprSomeInt)? "OK" : "BUG?");
std::printf("exprSomeType: %s\n", GetScalarConstantValue<Int4>(exprSomeType)? "OK" : "BUG?");
return 0;
}
Syntax error with simple INTERFACE block
Trying f18 on this simple test case
module m
implicit none
interface ifc
module procedure mp
end interface
contains
subroutine mp
end subroutine
end module
yields:
PGF90-S-0034-Syntax error at or near :: (/tmp/f18-d7d.f90: 4)
0 inform, 0 warnings, 1 severes, 0 fatal for m
Several issues here:
- The most obvious one: f18 throws a syntax error on perfectly valid code.
at or near ::is funny, because there is no::in the whole module.- The error does not mention the actual file name, but some cryptic /tmp file. In a parallel build with a gazillion files it can be very hard to see where the error is actually coming from.
- The line number is off if blank or comment lines are inserted.
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.