Previous Fixes

Wrong answers were received at +O3.

Subroutines ran much slower when compiled at +O3 than at +O2 for POINTER and ALLOCATABLE arrays.

Goto in OpenMP occasionally caused the compiler to fail.

There was an exponential allocation problem.

Occasionally, “private initialized used record” caused an assert.

Wrong answers were received in last (inout) arg to date_and_time intrinsic at +O2 and +O3.

There was a 10%+ performance improvement if transpose folded into matmul.

Inquire on an open file by name incorrectly padded out strings longer than the file name, resulting in garbage character in the string.

There was poor scalability for auto in parallel.

When compiling a file not in the current directory with +cpp_keep, the filename was given in error and warning messages were incorrect.

The compiler aborted on large real const (overflows).

Misaligned store caused segv.

The address of pruned block taken in block was not being pruned.

The DEFINE FILE statement aborted the bridge.

There was a front end abort on assumed size array.

There was an unsupported intrinsic SECNDS(real*8).

There was a TCG assert in bld_iltype_array.c.

The compiler aborted on a TSRUCTCON.

There was a failure to deallocate memory.

There was a need to handle TDECLARE allocatable DVAR as a pointer.

There was an unraveled type from ARRAYTYPE.

There was a wrong answer due to optimizing reductions even when +Ofltacc was specified.

A Caliper error sometimes resulted with errant unwind information; should be backed out.

There was a blockstack overflow.

DFIELD was not found.

There was a zext assert.

‘$OPTIMIZE level X off’ should default to command line opt level setting.

Occasionally, Wcount1 failed.

+objdebug was missing line numbers.

There was a tcg assert on ICUP.

There was occasional poor performance of POINTER formal arguments.

FORM=UNFORMATTED did not correctly handle big/little-endian conversion.

There was occasional poor performance with +Oopenmp.

There was an assert on ICUP.

Wrong answers occurred in wide mode large routines.

+O2 caused integer arithmetic loop logic errors.

Compilation occasionally aborted with *Compiler Internal Error.

There were incorrect Caliper line numbers for +O2 -g.

There were incorrect offsets for vax structures.

The compiler rejected *size (dimension) declarations.

Performance was degraded due to the absence of no parms overlap assertion.

+O2 occasionally caused an error.

There was a memory leak in the application program.

An error—*bad stackf90—occurred with +Oopenmp.

Multiplication by -1 and FNEG gave different answers for real*16.

The compiler occasionally generated extra local variables as evidenced by looking at the stack in the debugger.

The compiler occasionally aborted with -g on a structure with unions.

There was incorrect runtime behavior when using +i8.

When compiling some f90 codes with +O3 +Oopenmp, the compiler asserted after inlining a routine that was passed a record containing a dope vector.

The address of a member of a nested union was incorrect.

An error occurred with +Ofaster +O3.

There was inferior runtime performance for POINTER and TARGET arrays.

The compiler aborted when processing extraneous enddo statements.

Wrong answers were given with common blocks and thread local variables.

The compiler aborted when an integer was used as a case selector for a logical expression.

Debug information for array pointer upperbound was incorrect.

The compiler asserted after inlining a routine that was passed a record containing a dope vector.

Missed exceptions occurred when running exception handling codes compiled at +O3.

The compiler asserted when function ENTRYs contained assorted types in wide mode.

The compiler moved code around OMP lock calls.

When compiling a file not in the current directory with +cpp_keep, the filename given in error and warning messages was occasionally incorrect.

Default cpp options needed to be differentiated between PA and IA.

When using +asm/-S in combination with +P/+Oprofile, +asm/-S was ignored.

The compiler occasionally aborted with OpenMP and PREFETCH directives.

The compiler aborted when +i8 was used with values greater than 2**31.

The compiler issued an error message when the first argument to an elemental procedure was not an array.

Extensive use of automatic arrays in a subroutine with a very high call count resulted in performance degradation due to using malloc for automatic array allocation.

There was a segmentation fault compiling incomplete program.

There was a segmentation fault compiling f90 program with function returning pointer to array of derived type containing a private typed object.

The compiler aborted with a +DO switch.

The c$dir sync_routine directive was ignored with warning if +Oopenmp was used.

The compiler aborted when compiling the declaration of a deferred-shape array parameter.

A BOZ constant caused a compiler abort in case statement.

The compiler occasionally aborted when a parameter was equivalenced to a local variable.

There was a memory leak when a save statement was used with an automatically allocated array.

There was a compile time error with loop unrolling.

Wrong answers occurred when passing complex pointers at +O2 optimization.

The compiler occasionally aborted when trying to initialize a pointer field of a derived type.

The compiler aborted with the PREFETCH directive inside an OMP DO block.

The compiler aborted when +i8 was used with values greater than 2**31.

The compiler issued an internal error message when the first argument to an elemental procedure was not an array.

Inlined routines containing static (or Fortran SAVE) variables were giving wrong answers when compiled with +Oparallel or +Oopenmp.

The compiler aborted at +O3 in replace_interval.

Wrong answers were received from code within OMP locks.

Program aborted during runtime in $$divoI.

The compiler aborted during compiling rshift.

Segmentation fault when executing subroutines with a large number of arguments.

The compiler issued Error 215, Dummy argument or a private procedure cannot have a type that is private.

Performance problem caused by extra prefetches when using default cache line size.

Poor performance with multiple memory moves on some allocatable array types.

Subscript range error not detected in I/O implied DO.

The compiled program aborted when named parameters were used in some calls.

The compiler did not allow character function results to be used as unit numbers.

The compiler was generating a bogus error message.

The compiler failed to setup register r29 correctly.

The compiler did not call routines to print context during assert.

The compiler was performing an unnecessary error check.

The compiler was performing an illegal check.

The compiler was not ignoring C$Par when +Oopenmp is used.

Improved alias analysis for allocatable and automatic arrays.

Fixed symbolic handling of min/max expressions to avoid exponential expression growth.

Suppressed check when the array is null.

Fixed branch->skip conversion in wide mode.

A better check was provided to autopromote entity-type.

Increased the nametable size from 128 to 1024.

Prevent temporary copy of descriptor base address.

MIN1 and MAX1 calls are now converted internally to MIN0 and MAX0 when integer arguments are specified.

The compiler did not look for the alias name for function and subroutine interfaces.

The compiler aborts with redefinition of macro type.

Updated the compiler to accept label formats.

The compiler maintained context beyond the statement function context.

Emit subtype alignment of 16 bits for item.

The optimizer was hoisting a load without hoisting the associated store instruction, creating an uninitialized use of a reference.

The compiler was incorrectly calculating map region offsets.

The compiler was incorrectly optimizing away a variable that was still in use.

The compiler did not correctly output the SLT entry before the exit.

The compiler needed to extend array(1) to the end of the commonblock for alias purposes.

The compiler did not default to the correct type under the +i2 flag for BOZ constants.

The compiler should have issued a meaningful error diagnostic message.

The compiler's type checking was too strict and has been relaxed for IAND calls.

The compiler's type checking was too strict and has been relaxed for intrinsic calls.

The mechanism for handling the Open MP ORDERED directive needed to be enhanced.

The compiler has been changed to handle OPTIMIZE directives.

The compiler has been changed to handle SAVE_LOCALS directives.

Fixed symbolic handling of min/max expressions to avoid exponential expression growth.

The compiler did not issue a diagnostic message for undeclared function reference in a call.

The compiler did not allow iint to translate to int2 and int4 as appropriate.

The compiler did not pass int4 dimension to intrinsic.

The compiler incorrectly generated subscript checks on a zero sized array.

The compiler incorrectly determined that a variable equivalenced within a common block could be type-size promoted to match the size of address.

The namespace table was not large enough to handle the source file.

The compiler needed to check for valid frame size before running with bad input.

The compiler assumed loop indices to be integer*4 regardless of the compilation mode, causing unnecessary conversions during runtime.

An invalid but common idiom of equivalencing length 1 array to the beginning of a common block caused over optimization.

The compiler was incorrectly optimizing addresses to the LOC function.

The compiler did not correctly handle a boundary condition when writing a symbol across heaps.

An error in optimization caused incorrect code generation.

The compiler was not correctly generating line number references.

The present intrinsic returned wrong results.

The compiler was not checking to see if common blocks were indirect within functions and subroutines.

The compiler generated names incorrectly by using the kind precision instead of the type precision.

The parser did not allow f77 notation for 2 byte and 4 byte integer constants.

Error handing getarg and getarg1.

The compiler generated an error on a valid construct due to incorrect error checking.

An error in bounds checking prevented valid values as parameters to char.

Needed to encode the fact that fstream on typeint2 returns int4.

The compiler had a problem converting Holleriths to integers when using a bit or logical intrinsic.

The compiler turned on +Olibcalls even though the user specified +Onolibcalls.

The compiler was stuck in an infinite recursive call loop when compiling an incomplete type.

The compiler needed to recognize and correctly handle the $SHORT directive.

There was a bug coding the determination of the index intrinsic parameter.

The +i8 switch was not compatible with some of the OMP internal intrinsics.

The compiler incorrectly reported the hash line number instead of the line number.

The compiler failed to convert some types.

The compiler did not allow dimension as a function result attribute.

The CRAY target object was not being handled properly by intrinsics.

The function result type attributes were not being checked correctly.

The compiler recognized a hollerith field as an unnamed variable and issued invalid debug information.

C$pragma was not recognized, the compiler has been changed to ignore it.

The compiler was constant folding divides by zero.

The compiler created temporary variables but failed to privatize them in the parallel region.

A USE statement of a module which exported an operator definition within a nested scope caused an abort due to failure to clear the pushed operator count.

Fixed problem with line number handling.

Fixed problem with type conversion on array constants.

Fixed problem with graceful handling of error situation.

Fixed problem with more than one thread saving the result.

The compiler stored subspace lengths as integers; changed to use unsigned integers.

Changed the compiler to suppress errors for c$doacross, c$$, *$$, and !$$.

Multiple use statements caused a name collision.

Fixed the compiler to allow C$$$ to be a comment.

Fixed problem with #line directives throwing off the line counting the original source file.

Fixed problem with missing label from replicated nodes resulting from parallelization.

The data limit was too small; increased to 400 megabytes

Fixed uninitialized register problem causing intermittent wrong answers at high optimization levels.

Fixed problem with code to determine where the character length is stored is aborting.

Fixed problem of over-writing memory due to overflow of 16 bit field describing debugger position.

Fixed handling of the 'type' form of the print statement so that the label is recognized.

The compiler did not correctly infer data type for BOZ (typeless) constants from context.

Fixed bug in handling of the data statement.

Fixed the internal compiler assertion.

Fixed the bug in handling the +Ofaster compile option.

Fixed a problem with strength reduction of 64 bit multiplication by unsigned constants.

Removed an unused warning message "invalid arc calculation".

Added support for multiple arguments to the +U option.

To be consistent with f77, updated the compiler to accept 'type' as a synonym for 'print' when not within a declaration.

Fixed the compiler to resolve the omp_memcpy reference.

Fixed the OMP intrinsic assertion problem resulting from parameter mismatch.

Enhanced the compiler to allow up to 300 continuation lines.

Error in algorithm was causing the compiler to use workload/2 to guide scheduling. Changed this to use workload/numthreads.

Fixed the internal compiler error generated on a pack intrinsic.

Fixed the internal compiler error resulting in TCG in_descriptor.c assertion.

Fixed the compiler internal error.

Placement of $HP$SHARED_COMMON directive contrary to documentation was permitted in F77. Upgraded the f90 compiler to allow the f77 placement.

Fixed problem with intrinsic handling of dope vector array, resulting in bus error.

Fixed problem so that OMP directives are not lost.

Fixed bug in compiler for implicit open of file with unit number greater than 99.

Occasionally, there were problems with type keyword placement.

There was a TCG in_descriptor.C assert.

When compiling ftn code, a compiler error resulted.

An unused warning, “invalid arc calculation,” was removed.

There was a problem with zero sized array for SELECT CASE (char).

Private structure was imported.

Data statement on pointer was using null.

Occasionally, there was a problem when using +FPD combined with certain optimizations.

The compiler did not recognize the !$ALIAS form of the $ALIAS directive.

The compiler now returns an error message if an end do statement does not have a matching do statement.

The compiler was incorrectly calculating the destination address.

Occasionally, there was a problem with quadword results for entry statements.

The compiler included the concatenated file plus all of the individual files in the compile and link.

The compiler would occasionally assert when parallelizing a loop with an inlined routine.

The cputime routine did not return the correct value.

Occasionally, the compiler removed some necessary code.

The incorrect version of the error message file was built in the compiler.

There was a problem with the variable step transformation.

The compiler generated SAVE tags for an automatic variable.

The compiler did not clear the USEASSOCIATED bit for use variables which were privatized.

An INTERFACE assignment definition prevented the compiler from resolving an operator.

The compiler was using the incorrect variable hashlinenumber, which did not always track line number.

When propogating type tags from uplevel imported module to the nested routine, the compiler was not checking to see if the type tags had already been set.

The compiler inadvertently modified loops not directly attached to OMP DO directives.

The compiler was not correctly typing I*8 induction variables.

The compiler was incorrectly using the address of the repetition count instead of the repetition count.

The prefetch directive occasionally caused an internal compiler error.

The wrong answer problem with intrinsic function NINT was corrected.

The low level optimization of 64-bit code occasionally caused an internal compiler error.

When using +U77, there was a core dump and memory fault problem.

Using -g +z and +O2 caused an internal compiler error.

The compiler was updated to accept READONLY as a key word in OPEN. This was mapped to ACTION=’READ’.

Compile-time performance for large array initialization was improved.

The M and N edit descriptors were implemented for f77 compatibility.

The compiler aborted in the presence of redundant module uses.

The compiler was updated to allow the use of the intrinsic “size” function in array declarations.

Occasionally, the compiler aborted on very large arrays.

There was a compile-time performance problem with producing debug information at +O1.

The compiler failed to create threads if the user set CPS_STACK_SIZE too large.

The compiler now allows an EQUIVALENCE statement to follow variable declaration.

The compiler was updated to allow % as a comment character (FORTRAN 77 issue).

The compiler was updated to handle debug symbol indexes above 2**20.

The compiler aborted on nested routines with ALIAS directives.

An upgrade of the compiler now results in copy out semantics to optimize for contiguous memory when pointers to arrays are passed as parameters.

Wrong answers resulted when copying large string constants.

The compiler now allows “ SAVE” to be specified more than once for a variable.

The Fortran 90 compiler generated different output than the FORTRAN 77 compiler for 2**(-1).

An internal error resulted when evaluating a parameter statement that used the INT intrinsic.

The compiler now initializes character variables with length*.

The compiler calculated incorrect results for -10**30 when compiling using free-format.

The SAVE statement was fixed so that when no arguments are specified, it does not try to save values not valid for a save list.

Occasionally, there was a problem when using +O3 +Oall +Oautopar +Oparallel +Ovectorize.

The compiler returned an internal error when passing a character substring as a parameter.

The compiler did not recognize and default to generate code for PA2.0 architecture on L class machines.

The compiler did not handle “..” in relative source path correctly.

Occasionally, the shared common directive was not processed correctly.

The compiler did not allow common blocks to be mapped to system shared memory regions.

FORTRAN 77 and Fortran 90 processes could not shared memory whose size was not a multiple of 8 bytes.

The compiler did not unroll a simple loop in a timely manner.

The Fortran 90 compiler was taking over 100 times longer to compile a series of logical/equivalence statements that the FORTRAN 77 compiler.

The compiler asserted on source with large number of tokens.

Occasionally, there was an internal compiler error using +Oopenmp.

Return 0 was not handled properly.

The compiler now returns an error for the non-supported Complex(16).

The use of the PRIVATE directive caused an internal compiler abort with bad dictionary reference.

Fortran did not inline x**r, where r is a real constant with an integral value.

The basic block optimizer in the LLO disposed of a store that it incorrectly determined was redundant.

The optimizer tried to parallelize a loop with multiple exits and aborted. This type of loop cannot be parallelized. A warning message is now generated by the compiler and continues to compiler without parallelizing the loop.

The compiler was producing an unexpected type of initializer for an array of derived type when the initial value was an array constructor composed of structure constructors.

The compiler was using an incorrect memory area when several reduction variables were needed within a loop.

The compiler now generates an error message when unable to handle a disallowed variable.

The link process caused 2.0 libraries to get pulled in. 1.1 libraries are now pulled in.

The compiler now supports +multi_open to allow a file to be used in multiple Fortran OPEN statements.

Internal compiler tables were increased in size to resolve Compiler Internal Errors referencing f90numtab overflow with large data initialization.

The compiler failed to handle an extra set of parentheses in a character variable as an intrinsic argument.

IXOR of logical*1 was not supported.

A new switch, +io77, was added to support E and G format treatment of leading zeros to match FORTRAN 77 compiler output for easier comparison of prior results.

+fastallocatable caused errors with allocatable arrays that were SAVEd.

There was a Compiler Internal Error when a module defined a COMMON block and USEd another module that also defined the same COMMON block.

The compiler failed to correctly handle a constant argument to sizeof.

EQUIVALENCE statements with shared common were not handled correctly by the compiler.

Some OpenMP directives caused compiler internal errors when used with Modules.

When multiple load options occurred in a single compile line and the later options were shorter than the earlier options, incorrect behavior occurred.

The zero-based getarg solution provided by PHSS_20578 caused incompatibilities for some customers using shared library calls to getarg.

FSTREAM intrinsic only returned the lower 32 bits of FILE *fp pointer, causing problems for applications using wide mode (+DA2.0W).

Hollerith literals that extended beyond a single line behaved differently in FORTRAN 77 +es than with Fortran with +extend_source.

Request for closer correspondence of I/O output between FORTRAN 77 and Fortran 90.

The use of OpenMP runtime routines not yet available (such as omp_get_thread_num, omp_set_lock, omp_unset_lock, omp_test_lock) caused an abnormal exit from the compiler instead of returning an appropriate error message.

There were instances of a segmentation fault in the Fortran front end after an invalid alternate return was detected.

The use of +fastallocatable building module occasionally returned an error.

Previously, there was a problem with SPEC 191.fma3d.

The compiler aborted when a PARAMETER value was placed in a CHARACTER declaration.

Assigning 65535 to an integer*2 generated an error message.

Parallel reduction overflows were not handled correctly.

There was a difference in literal printing between f77 +es and f90 +extend_source.

Issues with Union overlapping other variables were resolved.

Assigned format labels in wide mode were not being handled correctly.

LOGICAL FUNCTION G*1() syntax was not accepted by f90, but was accepted by f77.

The OpenMP directive error handling was inadequate.

Integer exponentiation of negative numbers by negative numbers resulted in incorrect results.

Some variables beginning with Z in data statements were not being handled properly.

Logical statement functions containing floating points returned incorrect results.

Occasionally, there was a backend assert while compiling +O3 +Oparallel for a loop that had a multiple of 2 loop stride.

Alternate return arguments in an external subroutine call that was part of an IF statement caused an internal compiler error.

REAL*4 constants that exceeded the range of REAL*4 variables caused a compiler time error to be generated.

There was a need to support the OpenMP model of threadprivate.

Occasionally, compilation was slower at +O3 than at +O2, apparently due to the +Oloop_unroll_jam default set to “on.”

An assertion occasionally occurred if an indirect call omitted the alternate return entry on the first call.

WMATMUL at +O0 added special case for a scalar assign guard that looks like an array assign.

Occasionally, wdb did not find local variables with “info locals” because variable scope was declared to be a module rather than a routine.

Computed goto label references were not relocated for the cloned IF region associated with an OMP PARALLEL IF.

FORM=UNFORMATTED did not handle big/little-endian conversion.

Occasionally, there was an assert on ICUP.

wdb did not find local variables with ‘info locals’.

Occasionally, the compiler would abort due to emitting DSTRUCTON.

There were incorrect Caliper line numbers for +O2 -g.

There were incorrect offsets for vax structures.

Occasionally, the compiler rejected *size(dimension) declarations.

Performance was degraded (by 2-4x) when the no parms overlap assertion was no longer present.

There was a memory leak in the application program.

An error—*bad stackf90—occurred with +Oopenmp.

The compiler appeared to be generating extra local variables, as evidenced by looking at the stack in the debugger.

The compiler aborted, error 8901, with -g on a structure with unions.

When compiling some f90 codes with +O3 +Oopenmp, the compiler occasionally asserted after inlining a routine that was passed a record containing a dope vector.

There was an internal compiler error at +O2.

The address of a member of a nested union was incorrect.

The compiler occasionally aborted when compiling +O2 and +DSitanium2.

There was an internal compiler error, TCG assertion.

A 4 byte variable forced to 16bit alignment using equivalence caused TCG assert on size versus alignment.

The compiled program occasionally aborted when compiled with +O2.

The compiled program sometimes did not work when compiled with +DSitanium2.

The compiler asserted in f95store.c on private type in boundless array of derived type.

Wrong answers were occasionally given when code was compiled at +O2.

The compiler occasionally aborted when processing extraneous enddo statements.

The compiler occasionally aborted when an integer was used as a case selector for a logical expression.

Backend optimizer warning messages were using the linker name for routines (with the trailing underscore), not the name as it appeared in the original source.

The compiler occasionally asserted after inlining a routine that was passed a record containing a dope vector.

There were missed exceptions when running exception handling codes compiled at +O3.

The compiler sometimes generated inefficient code at +O2 due to missing floating point normalization code.

The compiler moved code around OMP lock calls.

There sometimes was a segmentation violation during cloning of a vararg routine.

When compiling a file not in the current directory with +cpp_keep, the filename given in error and warning messages may be incorrect.

+Oparallel disables speculative loads in parallel regions.

Default cpp options were identical between PA and IA; they should be different.

When using +asm/-S in combination with +P/+Oprofile, +asm/-S were occasionally ignored.

There sometimes were incorrect answers with optimizations greater than +O1.

There was an internal failure in low level optimizer, cm_misc.C.

The compiler occasionally aborted with OpenMP and the PREFETCH directive.

Fortran had options to select shared libF90 and libU77 libraries, but no corresponding option for libIO77.

The compiler occasionally aborted when +i8 was used with values greater than 2**31.

The compiler sometimes issued an internal error message when the first argument to an elemental procedure was not an array.

The compiler occasionally aborted with an error in the Arith.C routine of the low level optimizer.

The compiler sometimes generated inefficient code at +O3 +Oparallel.

There were wrong answers from generated programs at optimizations greater than +O1 when using -K.

Wrong answers were given from generated programs at optimization levels greater than +O2 with or without +Odataprefetch.

Extensive use of automatic arrays in a subroutine with a very high call count resulted in poor performance due to using malloc for automatic array allocation.

There was a segmentation fault compiling incomplete program.

There was a segmentation fault compiling f90 program with functions returning pointer to array of derived type containing a private typed object.

The compiler aborted with santity test failure in DataPrefetch.

The compiler aborted with +i8 in TMDATE.

The compiler encountered an internal error in ModSched.C.

Compiling with +Oparmsoverlap resulted in segmentation fault.

Compiling with +Oparmsoverlap resulted in low level optimizer failure.

The loop unroll factor was not being honored on loops which are inlined or cloned.

Compiling with +Ofenvaccess resulted in compiler abort.

The directive c$dir sync_routine was ignored with a warning if +Oopenmp was used. It should be supported regardless of optimization levels.

The compiler did not catch illegal parameters on a deferred shape array.

Wrong answers were given at +O2 optimization.

BOZ constant caused compiler aborts in case statement.

There was an internal failure in low-level optimizer, file Domin.C.

There was an internal failure in low-level optimizer, file PredAnaly.C.

The compiler occasionally aborted when compiling with both the +Onoinline and +Oprofile options.

The compiler aborted when a parameter was equivalenced to a local variable.

There was an internal failure in low-level optimizer, file SchedDriver.C.

Wrong answers with +O2 +DSitanium2.

There was a memory leak when a save statement was used with an automatically allocated array.

Wrong answers were generated when passing complex pointers at +O2 optimization.

There was a performance problem due to loss of loop unrolling.

The compiler occasionally aborted when trying to initialize a pointer field of a derived type

Inlined routines containing static (or Fortran SAVE) variables were giving wrong answers when compiled with +Oparallel or +Oopenmp.

Wrong answers were given from the code within OpenMP locks.

The compiler aborted during compilation of rshift.

The compiler issued an error that a dummy argument of a private procedure could not have a type that was private.

There was occasional poor performance with multiple memory moves on some allocatable array types.

The compiler occasionally aborted when named parameters were used in some calls.

The SIGXCPU signal did not abort programs that had the UNIX95 environment variable set when the programs were linked.

The compiler generated an error message for read(f(),*) when f was a character function.

The compiler generated an error message for a labelled ENDDO statement.

Traceback information did not always output when the compiler aborted.

The compiler generated an error when a statement function was used for a character declared with a parameter.

The compiler processed C$PAR directives even when OpenMP was used.

Occasionally, there was inferior performance for automatic and allocatable arrays.

Compiling at +O3 sometimes resulted in the compiler running out of memory in codes that accumulate a result from a large number of min or max expressions.

f90 option -C - reported an error with zero-sized array.

Implemented +A alignment option for backward f77 compatibility.

There were occasional wrong answers at +O2 +DA2.0W.

The compiler sometimes aborted with internal error 1000.

The compiler sometimes aborted with name table overflow.

The compiler occasionally had wrong answers at +O3 with automatic arrays.

The compiler issued an error message when MIN1 and MAX1 were called with integer arguments.

The $HP$ALIAS directive on interfaces was not always being honored.

The compiler was looking up constant operands in the dictionary table.

The compiler aborted on use of a format label with OpenMP; legal code was rejected.

The compiler gave wrong answers in 64 bit mode when using statement functions.

The compiler aborted for +A compilation of a 2 byte aligned common item.

Occasionally there were extremely long (infinite) compiles on case statements.

When using allocatable arrays embedded in a f90 record type, the program would bus error or seg fault during the program execution.

The compiler aborted when -g was specified with union map regions containing only one component.

The program received wrong answers at +O2.

GDB could not stop at the end of a program due to missing SLT entry.

The executable received wrong answers with parmsoverlap at optimization level +O3.

Request for O’400’ and Z’400’to be treated as 2 bytes for intrinsic calls.

The compiler aborted when a PARAMETER statement redefined a COMMON definition.

The compiler rejected IAND (I4, i2const) with +i2.

IAND and IOR did not accept a mixture of INTEGER*2 and INTEGER*4 arguments.

The compiler mishandled the ORDERED clause within nested parallel directives.

The compiler did not honor f77 style OPTIMIZE directives.

The compiler did not honor f77 style SAVE_LOCALS directives.

Compiling at +O3 resulted in the compiler running out of memory in codes that accumulate a result from a large number of min or max expressions.

The compiler aborted when an undeclared function reference was used in a call.

Intrinsic iint was not allowed with type int.

The compiler aborted with +i8 on SIZE(array, dim) intrinsic.

The compiler generated runtime checks causing the program to abort when -C was used with zero-sized arrays.

The compiler aborted on NASTRAN code.

The compiler aborted on very large source files.

The compiler aborted with an internal error with large real*8 arrays.

Inefficient code was generated in 64-bit mode for loop indices.

The compiler issued internal error messages.

A wrong answer was received at optimization level +O2 due to use of EQUIVALENCE.

A wrong answer was received at optimization level +O2 when using the LOC intrinsic.

The compiler was slow to compile case selectors with a range.

The compiler issued a bogus error.

The compiler generated wrong answers in wide mode at optimization level +O3 when using integer*8 induction variables.

The debugger was not setting breakpoints in functions included via header files.

The present intrinsic returned the wrong result when an optional parameter was not passed by the calling program.

Incorrect code was generated when an indirect common block was used in a subroutine.

The compiler generated incorrect names for complex types for use by the debugger.

There was an f77 compatibility issue regarding nnnnl and nnnJ notation.

The compiler generated an internal error on call to getarg when using +getarg1.

The compiler occasionally aborted with an assertion error.

The compiler generated an error when values greater than 127 were passed to the char intrinsic in a PARAMETER statement.

The compiler generated low-level optimizer internal error messages.

The compiler aborted with a segmentation violation when a function with alternate returns was called.

The compiler aborted on fstream with integer*2 result assignment.

There was an error compiling hollerith constants when used with the IAND intrinsic.

The compiler ignored +Onolibcalls at optimization level +O2.

The compiler aborted when parallelizing OpenMP programs with parallel sections.

The compiler aborted in a segmentation fault when compiling an incomplete type at +O3.

The compiler did not recognize the $SHORT directive, which is needed for f77 backward compatibility.

The compiler aborted using +i8 when compiling the index intrinsic.

The compiler aborted in wide mode with the +i8 switch when compiling OMP intrinsics.

The compiler reported the wrong line number in error messages when the -I include path is used.

The compiler gave incorrect results for integer*1.

The compiler aborted compiling set_num_threads call using +autodbl in 64-bit mode.

The compiler issued an error 300 message when compiling a generic function.

The compiler issued an error message for a character array argument whose length was different that a specific formal parameter character array argument.

The debugger did not stop at the correct line number.

The compiler aborted with segmentation fault after correctly reporting errors.

Random wrong results sometimes occurred in Open MP code.

The compiler did not correctly handle BOZ constants in intrinsic function calls.

Code produced at optimization level +O2 aborted with a bus error.

There was a compiler error when compiling a recursive function; abnormal exit from bridge.

The compiler aborted when the source file contained only comments and blank lines

The compiler asserted with "Backend Error" when PARAMETER was used with RESHAPE.

The compiler did not accept the incremental linking options +ild and +ildrelink.

The compiler asserted on the data statement which uses rep and has another overlapping data statement

The compiler aborted with f90: Signal 6

Use of the +Ofaster compile option caused a bus error

There was a problem shifting a 64 bit integer by 64 bits

The compiler gave an internal error with array assignment.

Wrong answers were occasionally received for reentrant subroutines

The use of 300 continuation lines sometimes caused internal compiler error.

The label on a 'type' statement was lost.

The compiler aborted when -C was used

The compiler aborted with a low-level optimizer message

The compiler was changed to suppress errors for c$doacross, c$$, *$$, and !$$.

The compiler emitted a warning for an OMP parallel directive.

The compiler aborted when a module was used multiple times within the same source file.

The compiler issued an error message for c$$$.

The compiler generated a missing label assertion on Open MP code.

The compiler appeared to limit initialized DATA to 42 megabytes, much smaller than F77.

The compiler emitted an assert on operator in INTERFACE definition.

The compiler asserted with -g on a program with a hollerith constant.

The compiler issued an error with +Oopenmp a pragma directive.

There was a problem with compile-time evaluation of math function calls with constant arguments.

The compiler issued an error message when defining a generic function using an INTERFACE block when the function specification contains a RESULT clause.

The compiler aborted during handling of a CRAY pointer object.

The compiler encountered an internal error in low-level optimizer file RaDf.c.

There was a compiler internal error with the parallel directive.

The $alias directive was not being accepted.

Character declarations which follow the equivalence declarations were syntactic errors due to the grammar specification.

There was no debugger support for Cray Pointers.

Wrong answers were received with assigned GOTO compiled at +O3.

A mixed multiple entry caused an abort.

There was poor optimization of arrays with descriptors at +O3.

Array declaration rejected when it involved specifying array size based on a previous arrays size declaration.

Certain uses of zero-sized arrays/character variables caused compiler asserts.

Poor performance sometimes resulted on array sections as actual arguments.

There was occasionally excessive compile time for data statements that create large initialized arrays.

+Ostore_ordering was not being honored.

Exact +cat option placement on command line changed behavior.

Empty directive nests were not being supported.

The omp_set_num_threads intrinsic did not behave as expected.

There were problems with -exec/-dynamic/-minshared interactions.

There was a +DD64 assigned format compiler abort.

Interference between c$dir and c$omp.+ild/+ildrelink was not recognized correctly.

There was an application bus error.

There was an assert on multi-dimensional array constant in record.

The REPEAT constructor compiler asserted.

Pack intrinsic / parenthesized expression; compiler assert.

A compiler internal error occurred when importing private structure.

Wrong answers were received for some parallel loops.

The compiler sometimes didn’t support enough continuation lines.

SELECT CASE (chartype) caused a compiler assert.

TYPE statement in declarative region rejected with syntax error.

OpenMP integer*8 loops were not shared.

OpenMP loops were not always trip counted.

There was an occasional abnormal exit from the compiler.

The source with the includes files was not fully debugable.

Wrong answer was received at +DD64 +O2 +i8.

The compiler aborted with privatized USE.

There was a compiler error with allocatable arrays and the save statement.

There was a module not found error messages none: Not linking with the IA64 unwind library.

OMP Copyin clauses were not correct.

Undocumented M edit descriptor from F77 needed to be supported in F90.

Externally declared omp callables were not getting the right linkages.

There was an assert on an unexpected DLABEL.

OMP callables required treatment as external rather than intrinsic.

Reduction on subtract incorrectly subtracted.

There was a memory corruption on large OMP codes.

There was an occasional problem with automatic arrays privatized in parallel region.

Some OpenMP reductions were not recognized as valid.

The OMP fmt label refs caused error.

Occasionally, there was an optimization problem with the use of the option +O2. Different results were calculated if the binary was compiled with different optimization levels.

When compiled in 64-bit mode, the executable received a bus error.

The debug information for arrays of characters passed by descriptor character cstring_arr (:,:)*(*) was incorrect.

Occasionally, v2.3 did not autopar parallelize the indicated loop.

When using +Onolimit +Odataprefetch +O3 +Oprocelim +Olibcalls, ccom entered an infinite loop.

Previously, +Onoloop_transform inhibited loop parallelization.

Fortran range checking displayed line #0 instead of the actual line number.

+Onoinline did not work for call sites that were transformed from indirect calls to direct calls.

Fortran ignored 17 loop_parallel directives in LS-DYNA.

+DA1.1 +Odataprefetch generated an internal code error.

Inlining dropped the register storage class of certain variables.

The compiler would occasionally have an abnormal termination when compiling at optimization level +O3 or higher.

Wrong answers were generated when computing polynomials at +Oparallel.

Occasionally, inlined code created a situation where loop recognition failed to recognize a perfect nest, thereby disabling a critical interchange. The HLO loop recognition phase has been improved to handle such cases.

Previously, +i8 +O2 caused an infinite loop in the compiler.

Using +i8 and +O2 occasionally resulted in an internal error with the Fortran compiler.

There were instances when the compiler produced an internal error if you were using ‘-g’.

The Fortran driver was updated to infer +DA<model> machine parameters.

A new command-line flag— +sharedlibF90 —resolves potential issues with the F90 driver trying to link with the shared version of libF90. See Command-line flags elsewhere in this document.

The PACK intrinsic has been corrected to properly handle nonstandard LOGICAL values. Previously, a segmentation fault would occur if nonstandard LOGICAL values were encountered by this intrinsic.

In previous versions of the compiler, the MERGE intrinsic was unimplemented, resulting in compiler aborts. Instances where this happened included when the compiler encountered complicated expressions involving derived types or character strings. The MERGE intrinsic has been corrected so that it properly handles complicated expressions.

(HP-UX 11.0 only) Fortran has been corrected so that it works in wide mode (64-bit addressing) when a derived-type selector is used on an array.

The LBOUND, UBOUND, and SHAPE intrinsics asserted when their result array was non-contiguous.

The Fortran compiler previously declared some variables as thread_private when they were not. The Fortran memory classes have been changed to correct this.

(HP-UX 11.0 only) In certain situations, Fortran would abort at +O3 +Oparallel.

In certain situations, Fortran would abort at +O3 +Opal.

(HP-UX 11.0 only) Using CXperf profiling support option +pal with optimization enabled caused Fortran to assert.

Using +autodbl occasionally resulted in an assert.

(HP-UX 11.0 only) The HP Performance Analysis Tool CXperf can now profile Fortran applications with empty routines and compiled with +pa. This is a Fortran fix which corrects the previous problem of a resulting coredump.

Wrong answers were generated by Fortran at +O3.

When the code specified loop interchange, the compiler would not honor c$dir no_loop_transform in certain situations.

-g +objdebug now works in the same manner as +objdebuf -g so that +objdebug takes precedence.

The compiler would occasionally run out of memory at optimization level +O3.

SELECT CASE statements with REAL*4 ranges/values failed when +autodbl4 used.

Explicit double precision constants (3.0D4) were corrupted when +autodbl was specified.

The ADJUSTL intrinsic returned wrong answers when its argument was a parenthesized character constant.

modulo(x,y) returned incorrect results when -1 < x/y < 0.

The ES format descriptor printed zero values incorrectly.

A never-referenced variable name which was also a common block name caused syntax errors when used in an EQUIVALENCE statement.

Using 4-byte integer DO loop indices in wide mode (+DA2.0W) incorrectly inhibited a wide range of optimizations and auto-parallelization.

Certain uses of variable length character variables with the POINTER attribute caused intermittent aborts at runtime.

NAMELIST input of character arrays was not compatible with FORTRAN 77 (non-standard usage of a scalar subscript but multiple values is now accepted).

NAMELIST READs in wide mode (+DA.0W) sometimes corrupted memory and caused unpredictable aborts.

Some character expressions in a SELECT CASE statement were evaluated more than once.

SYSTEM_CLOCK sometimes returned an invalid value.

Short Hollerith initializers (i.e., 1h3) in DATA statements for REAL variables caused an internal error.

Using an INTENT(IN) dummy argument in a subsequent initialization expression sometimes caused an internal error.

Referencing a character variable via a substring and later as if it were a function caused an internal error. Now a syntax error is issued.

Routines which indirectly used the same module many times caused the compilers symbol table to become corrupted. The compiler now detects and ignores the indirect redundant USE statements (it has always ignored directly visible redundant USE statements).

Several internal errors caused by the +DA2.0 flag have been fixed.

All of the compiler directive code has been reimplemented. Many observed and undiscovered bugs with memory class and loop-based directives have been fixed.

An unsubscripted integer array used as a FORMAT is now assumed to be a character string format, and not an ASSIGN statement format.

Zero-length character type array constructors caused an internal error.

The ftnxx environment variables were ignored in wide mode.

When a library (.a file) was listed several times on the command line, all but one of them was (incorrectly) removed.

Cray-style pointers were only 32 bits in wide mode unless +autodbl[4] was used. Now they are always 8 bytes in wide mode.

In previous versions of Fortran, space deallocation could potentially fail. This occurred when initialized commons were used in the presence of equivalences.

Additional NULL pointer checks have been added to the Fortran compiler. This fixes compile-time aborts in the optimizer portion of the compiler.