home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Professional
/
OS2PRO194.ISO
/
os2
/
patches
/
cset50
/
csdfixes.lst
next >
Wrap
File List
|
1993-06-17
|
51KB
|
634 lines
╒════════════════════════════════════════════════════════════════════════════╕
│ │
│ C Set/2 Release 1.0 Fixes │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ APAR Number │ Problem Description │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03523 │ Optimization Problem: Bad register selection causes │
│ │ general protection fault at runtime. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03662 │ Optimization Problem: Bad register selection around a │
│ │ call causes incorrect output at runtime. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03682 │ Optimization Problem: Tail call optimization was altering │
│ │ a register erroneously. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03767 │ The compiler could not open files with names containing │
│ │ DBCS characters where the second byte of the characters │
│ │ was 0x5C. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03923 │ Optimization Problem: Generated floating-point code was │
│ │ causing the floating-point register stack to overflow or │
│ │ underflow. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03948 │ Optimization Problem: Multiplying by constant negative │
│ │ numbers which are powers of 2 was causing incorrect code │
│ │ to be generated. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03952 │ Optimization Problem: Multiplying by constants that are │
│ │ near powers of 2 was causing incorrect code to be │
│ │ generated. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ03957 │ Compiler was emitting object records longer than the │
│ │ linker's 1024 byte limit. This causes the linker to │
│ │ produce the message "L1057: data record too large. │
│ │ │
│ │ NOTE: There is more than one cause for this symptom │
│ │ and fix coming soon. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Compile time performance was improved. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ The compiler was unable to find files in a subdirectory │
│ │ on a LAN drive. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00008 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ04295 │ The kbhit library function was not working. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00009 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ04465 │ The cprintf, fprintf, printf, and sprintf functions were │
│ │ not printing floating-point values between 0.5 and 1.0 │
│ │ correctly when zero precision was specified. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00010 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ04602 │ Optimization Problem: Simple loops with induction variable│
│ │ increments greater than one were being incorrectly turned │
│ │ into memset or memcpy builtin function calls. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ04604 │ When the compiler turned switch statements into jump │
│ │ tables, default code segment was always being referenced │
│ │ even the if the function containing the switch statement │
│ │ was specified in an alloc_text pragma. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ04652 │ Optimization Problem: The stack pointer was not being │
│ │ decremented before an indirect _Optlink call where the │
│ │ return value was being used as a parameter to a tail call.│
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ04674 │ When #pragma handler was specified for a 32-bit callback │
│ │ function the compiler generated bad code for copying the │
│ │ parameters from the 16-bit stack to the 32-bit stack. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00011 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ04811 │ Incorrect code was being generated for a complicated │
│ │ expression where a short variable was being added to the │
│ │ address of an element of an array of structures. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05088 │ Optimization Problem: The compiler was trapping when │
│ │ optimizing a loop containing a divide and modulo operation│
│ │ with the same operands. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05100 │ Optimization Problem: Incorrect code was being generated │
│ │ for a switch statement containing a case zero where the │
│ │ switch variable had to be converted to an int from an │
│ │ unsigned char. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05124 │ Incorrect code was being generated when the result of │
│ │ comparing two shorts with less than or greater than │
│ │ operators was stored into an integer variable. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05140 │ Incorrect code was being generated for _Optlink functions │
│ │ that have a number of floating-point or aggregate │
│ │ parameters followed by integer parameters. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00012 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ05013 │ The compiler was trapping when trying to compile a │
│ │ complicated expression where the address of an element of │
│ │ an array of structures was indexed and then a member of │
│ │ the structure was accessed. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ04674 │ The problem with #pragma handler on callback functions was│
│ │ really only a problem with _Far16 _Cdecl callback │
│ │ functions. So the fix in CSD0011 broke the case where │
│ │ #pragma handler was used on a _Far16 _Pascal callback │
│ │ function. Now both work. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ04390 │ The C runtime termination routine was not freeing all │
│ │ storage allocated during initialization. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05087 │ Partial static initialization of a structure containing │
│ │ a union containing a structure containing bitfields was │
│ │ not working. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Some enhancements were made to the compiler to reduce │
│ │ memory usage dring compilation and therefore reduce │
│ │ compile times. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00013 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ05087 │ The assembler listing was incorrect after the real problem│
│ │ was fixed in CSD0013. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05225 │ Optimization Problem: The compiler was trapping when │
│ │ optimizing a procedure containing a loop nested within │
│ │ another loop where an invariant in the inner loop was an │
│ │ induction variable for the outer loop. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05230 │ Optimization Problem: Incorrect code was generated for an │
│ │ Optlink function containing a loop where an invariant was │
│ │ a register parameter and it was used in a conditional │
│ │ expression within the loop. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05393 │ Optimization Problem: The compiler was trapping when │
│ │ compiling code with consecutive calls to strcat with the │
│ │ same first parameter. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05431 │ Optimization Problem: The compiler was incorrectly │
│ │ removing a store to a local variable before a loop. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05450 │ The thunk prolog routine was using 64K too much stack in │
│ │ certain situations. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00014 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ05225 │ The original fix for this problem may have caused other │
│ │ optimization problems. Now we believe that we have a │
│ │ complete fix for this problem. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05303 │ Optimization Problem: A parameter in an _Optlink function │
│ │ that was assigned to a global register was not being kept │
│ │ alive long enough. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05737 │ A "data record too large" message from the linker was │
│ │ being generated when a union where the first member was │
│ │ more than 1024 bytes smaller than another member was │
│ │ being initialized OR when an aggregate within a user data │
│ │ segment was uninitialized. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05722 │ The compiler was generating an IMUL instruction with an │
│ │ operand size prefix but the constant was 32 bits long │
│ │ instead of 16-bits long. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05723 │ Optimization Problem: The compiler was trapping when │
│ │ trying to optimize a floating-point intensive procedure │
│ │ where floating-point spills and reloads were necessary. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05716 │ The compiler was emitting stack probes when the size of │
│ │ all local variables was greater than 4K instead of when │
│ │ the size is greater than 2K. In some cases, stack probes │
│ │ were being emitted in the wrong place as well. This │
│ │ would cause strange traps to occur in multi-threaded │
│ │ programs. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05728 │ Stack probes were not enabled during compilation of │
│ │ multi-threaded runtime library code. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05556 │ The runtime library termination routine was not checking │
│ │ to make sure runtime initialization had completed. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Provides a means to set the number of spaces to be │
│ │ inserted when tabs are encountered in the source file. │
│ │ The default tab expansion is 8 spaces, as it was in the │
│ │ orignal IPMD. A new environment variable, PMDTAB, is now │
│ │ available to customize the tab expansion constant. For │
│ │ example, "SET PMDTAB=5" causes 5 spaces to be inserted │
│ │ for every tab. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05863 │ In multithreaded applications, the debugger would perform │
│ │ a "Run" when a "Step over" or a "Step debug" was │
│ │ requested. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05148 │ Internal debugger errors were sometimes reported when │
│ │ performing a "Find" and when scrolling the source view. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05117 │ Occasionally the debugger would automatically shut itself │
│ │ down when creating or scrolling a source view. Included │
│ │ in this APAR is a problem in which the application is left│
│ │ active when the debugger terminates after an exception. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ General internal PM debugging enhancements. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ General internal storage window enhancements. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ The name displayed for a subscripted array (i.e., x(i)) │
│ │ is not always updated - if the value remains the same │
│ │ while the name changes, the name is not updated. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ If the stack window is open and data is entered in the │
│ │ application window, the stack view can display the wrong │
│ │ part name for a function name. This can also cause the │
│ │ debugger to crash if the focus is changed between the │
│ │ source, the stack, and the application several times. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00022 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ NOAPAR │ Exception handler registration records were causing stack │
│ │ chaining to be disabled because of their location in the │
│ │ instruction stream. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06109 │ Optimization Problem: Multiplication by some particular │
│ │ constants was being done incorrectly when the /G4 switch │
│ │ was specified. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06417 │ The compiler was not generating code to check for NULL │
│ │ before calling _DosSelToFlat when a 16-bit pointer was │
│ │ being converted to a 32-bit pointer. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06023 │ Optimization Problem: The wrong register was being used │
│ │ when a virtual global register was reassociated with a │
│ │ different real register. This showed up with nested loops │
│ │ where an induction variable in an outer loop is an │
│ │ invariant within an inner loop. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Optimization Problem: Multiplication by certain negative │
│ │ constants was being done incorrectly. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06022 │ Optimization Problem: A parameter register was not being │
│ │ kept alive until the end of a loop when the last use of │
│ │ the parameter is within the loop. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ05928 │ Floating Point Number Formatting Problem: Printf │
│ │ formating with %g was crashing if the precision │
│ │ requested exceeded 16 digits. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06439 │ Ceil and Floor Functions did not restore 387 flags. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06454 │ Exception Handler Problem: If an exception occurs during │
│ │ a library critical routine, and a second user exception │
│ │ occurs while in a nested critical routine belonging to │
│ │ the first exception, the exception handler will loop and │
│ │ hang the process. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06436 │ Optimization Problem: Statements of the form: │
│ │ "if (bool) {x.a = const} else {x.b = const}" were being │
│ │ simplified incorrectly to "x.a=const". │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00026 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ NOAPAR │ DBCS enablement changes to IPMD. │
│ │ Add the keyboard status indicator to the dialogs. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ DBCS enabled. Fixed the stack probe option. │
│ │ Updated help text for the stack probe option and added │
│ │ the key help for the DDE4CSET.DLL. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06460 │ Optimization Problem: If an extern is modified inside a │
│ │ loop while it's in a register, jumping from within that │
│ │ loop to a return could sometimes bypass the code that │
│ │ copies the register back to memory. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06459 │ Optimization Problem: Consecutive calls to the memmove, │
│ │ memcpy, or memset functions with similar destination │
│ │ addresses could fail if the returned address from the │
│ │ first call is used before the second call. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06584 │ Occasionally with optimization, loop exits coinciding with│
│ │ function exits caused incorrect termination of the loop. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06610 │ Optimization Problem: Statements of the form: │
│ │ "if (bool) {x = const0} else {x = const1}" could cause │
│ │ a compile-time exception if "x" is an address. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06593 │ Optimization Problem: Statements of the form given above │
│ │ (PJ06610) could be incorrectly optimized if the "bool" │
│ │ expression does not contain a relational or equality │
│ │ operator. For example: (bool) or (!bool). │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06637 │ Passing structs by value during _Optlink calls could cause│
│ │ the caller to incorrectly set up subsequent parameters. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06742 │ The compiler could incorrectly set up the return register │
│ │ for calls to _DosFlatToSel with 16-bit function pointers, │
│ │ and thus cause register selection problems. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06583 │ Optimization Problem: Gotos within the inner loop of a │
│ │ nested loop could cause incorrect spilling of a variable │
│ │ if the variable was used in the inner loop but not in │
│ │ the outer loops. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06813 │ Optimization Problem: A floating-point cast of the same │
│ │ integer variable both before and inside an "if" could │
│ │ cause the floating-point stack to become inconsistant. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06623 │ Freopen Library Function: freopen function did not allow │
│ │ the changing of the text/binary mode of a standard stream │
│ │ without redirecting to a different file. For example: │
│ │ freopen( "", "rb", stdin ); │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06904 │ Relax some of the restrictions on arrays of incomplete │
│ │ types so that cfront-generated code can compile. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06776 │ When a comma operator is used to evaluate the address │
│ │ of a function being called, an internal compiler error │
│ │ occurs. Code Generation of Front End now fixed. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00028 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ06624 │ Optimization Problem: Using the address of a parameter │
│ │ passed in a register could cause the compiler to trap │
│ │ if basic blocks are merged. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06768 │ Optimization Problem: Multiplying two addresses that have │
│ │ been cast to integers could cause the compiler to trap. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06846 │ Optimization Problem: A large number of consecutive │
│ │ statements that each use values calculated in previous │
│ │ statements could cause the swapper to grow very large. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06841 │ Optimization Problem: The compiler could trap if the last │
│ │ "if" in a loop turns into a jump to the top of the loop. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00030 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ06929 │ Optimization Problem: A ternary within a loop could in │
│ │ very rare cases cause a global register to be incorrectly │
│ │ clobbered. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06881 │ Folding of the following expressions incorrectly removed │
│ │ x if x had side effects: (0 / x) ---> 0 │
│ │ (0 % x) ---> 0 │
│ │ (x % 1) ---> 0 │
│ │ (x % -1) ---> 0 │
│ │ (x * 0) ---> 0 │
│ │ (x & 0) ---> 0 │
│ │ (x | -1) ---> -1 │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06862 │ Optimization Problem: This is a more general fix to the │
│ │ problem dealt with in PJ06846. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06908 │ Without optimization, casts from an unsigned short to a │
│ │ double could yield incorrect conversions. The problem │
│ │ disappears when compiling with /O+. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Allow ASCII characters above 0x80 to display in the │
│ │ source view of the debugger │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00032 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ07151 │ Optimization Problem: Transformation of a simple loop to │
│ │ either a memset or a memcpy could create initialization │
│ │ problems if the loop induction variable is unsigned. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07244 │ Optimization Problem: The constant value stored during │
│ │ the builtin memset could be incorrectly calculated for │
│ │ char and short types. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06920 │ Preprocessor Problem: If a macro replacement token is │
│ │ empty, in some cases we were erroneously substituting │
│ │ it with a right parenthesis. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07198 │ Optimization Problem: Dead store removal within loops │
│ │ failed to consider conditional stores and thus could │
│ │ incorrectly remove a store that was not dead. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ06024 │ Optimization Problem: Bad invariant code motion could │
│ │ result in a general protection fault at compile-time. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07215 │ Optimization Problem: Calls to 16-bit functions could │
│ │ cause inappropriate tail-call optimization to occur. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07253 │ An internal problem could cause a compile-time general │
│ │ protection fault when generating debugger information │
│ │ without optimization. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07259 │ FE Problem: When utilizing a pointer to a pointer to data,│
│ │ the compiler is only dereferencing the pointer once. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Optimization Problem: An internal problem could cause │
│ │ a compile-time general protection fault when keeping a │
│ │ floating-point parameter alive in a register. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00034 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ NOAPAR │ Optimization Problem: Strength reduction of a │
│ │ compiler-generated constant could result in a general │
│ │ protection fault at compile-time. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Optimization Problem: Tail recursion elimination could │
│ │ incorrectly handle parameter aliases. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ BE Problem: Incorrect code may be generated for _Far16 │
│ │ _Pascal callback functions that return floating-point │
│ │ types. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07295 │ Performance improvement of strstr. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07356 │ _fullpath was not returning the correct result when │
│ │ ..\ was passed in as the partial path. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ BE Problem: Incorrect code may be generated with the │
│ │ combination of _alloca and #pragma handler. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00036 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ07414 │ Initialization Problem: Floating point 387 not cleared │
│ │ during runtime initialization. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07631 │ Calloc Problem: Storage returned from calloc was not │
│ │ set to zeroes after a realloc to a smaller size. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Dump Problem: Incorrect NPX values were being displayed │
│ │ for floating point exception dumps. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Fastsem: Making Fastsem multiprocessor safe. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07672 │ I/O problem: When a nonseekable device (e.g. LPT1, CON, │
│ │ pipe, COM1) is opened with append mode, any attempt to │
│ │ write to such device will fail with an OS/2 error 132. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07673 │ FE Problem: Pointer to structure member (that is a struct)│
│ │ assigned to pointer to structure member (also a struct) │
│ │ and then applying dot operator caused incorrect code. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07600 │ DDE4.NDX - Removed incorrect references to the │
│ │ toolkit information. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00038 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ07710 │ Optimization Problem: Casting char or short types to a │
│ │ long type and then performing a bitwise AND on the result │
│ │ could lead to incorrect code generation if the upper 16 │
│ │ bits of the AND mask contain set bits. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Optimization Problem: A do loop with a complex while │
│ │ condition could be incorrectly unrolled. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Optimization Problem: An internal problem could cause │
│ │ a compile-time general protection fault when destroying │
│ │ unreachable code. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07429 │ Optimization Problem: If the last use of a floating-point │
│ │ parameter occurs near the beginning of a function before │
│ │ any control flow statements, that parameter could be left │
│ │ on the floating-point stack when the function returns. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07422 │ FE Problem: Compiler is erroneously generating warning │
│ │ message EDC0830 on some enum usage when compiled with │
│ │ -Ke+ switch. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07766 │ Compiler Trap: The compiler would generate an exception │
│ │ if a bitfield was post-incremented and used as the right │
│ │ hand side of an assignment within the same statement. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00040 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ07908 │ Library Problem: Exception occurs when user presses │
│ │ control c in a conio input routine. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07909 │ Library Problem: Memory allocation performance improvement│
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07984 │ Optimization Problem: Constant propagation could be │
│ │ performed incorrectly when a store to one member of a │
│ │ union clobbers a store to another member. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ07986 │ Optimization Problem: If the last usage of a register │
│ │ parameter is a store in the last block of a loop, then │
│ │ incorrect code could be generated. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08032 │ Optimization Problem: Post-incrementing a variable that │
│ │ is used as a parameter to consecutive function calls could│
│ │ cause incorrect constant propagation. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08046 │ Library Problem: Change macro definition of isascii. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08065 │ BE Problem: Pointer subtraction, where the pointers point │
│ │ to members of a structure, could cause incorrect code │
│ │ generation. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08066 │ Optimization Problem: A ternary that uses volatile unions │
│ │ could cause incorrect code generation if the result of the│
│ │ conditional expression is used immediately after. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00042 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ NOAPAR │ Compiler Trap: An internal problem could cause │
│ │ a general protection fault during compilation. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Library Problem: Fixed obscure malloc/heapmin bug. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00044 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ NOAPAR │ Optimization Problem: An internal problem with loop │
│ │ invariant code motion could cause a compile-time error. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08413 │ BE Problem: Under certain conditions, memset was not │
│ │ clearing the upper 2 bytes of the value register. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08285 │ BE Problem: Incorrect code generated when right shifting │
│ │ an unsigned char, which has been casted to a long, and │
│ │ then assigning the result to an unsigned char. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08300 │ RT Problem: _fullpath cannot parse "G:" , "C:", etc. │
│ │ This is an API behaviour. Since C386 can parse the │
│ │ above correctly, we decided to modify the call to │
│ │ the API to accept "C:", "G:", etc. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08415 │ Optimization Problem: Global folding could be performed │
│ │ incorrectly when a store to one member of a union clobbers│
│ │ a store to another member. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08286 │ Optimization Problem: Gotos near the bottom of a loop │
│ │ which jump to code right after the loop could cause │
│ │ incorrect code to be generated. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08456 │ BE Problem: Returning a struct by value could result in │
│ │ incorrect code generation if the return statement calls │
│ │ another function whose return type is a pointer to struct.│
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ Optimization Problem: Tail call optimization could │
│ │ generate incorrect code if the current function contains │
│ │ a call to _alloca. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08473 │ FE Problem: Casts from function pointers to segmented │
│ │ data pointers were improperly being flagged as errors. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00046 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ08488 │ Optimization Problem: A parameter register could be │
│ │ incorrectly clobbered if a use follows a def. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08489 │ Optimization Problem: The register assigner could │
│ │ choose the wrong register when trying to optimize the │
│ │ use of byte registers. (ie: AL vs AH) │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08487 │ Optimization Problem: A problem in the builtin memmove │
│ │ could cause a run-time general protection fault. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08486 │ BE Problem: Assigning a function returning an aggregate │
│ │ to an array element whose index results from evaluating │
│ │ another function could cause incorrect code generation. │
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00048 │
│ │
╞═══════════════╤════════════════════════════════════════════════════════════╡
│ PJ08712 │ BE Problem: Casting 0xFFFF0001 to unsigned long and then │
│ │ to unsigned short incorrectly gives 0 instead of 1. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ00000 │ FE Problem: pointers in 16-bit function definitions │
│ │ were not getting _Seg16 qualifiers. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08715 │ Optimization Problem: An internal problem with strength │
│ │ reduction could cause a compile-time error. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08714 │ BE Problem: An internal problem with code generation │
│ │ could cause a compile-time general protection fault when │
│ │ generating debugger information. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ BE Problem: Copying large parameters (> 4096 bytes) onto │
│ │ the stack could be done incorrectly. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ BE Problem: An internal problem occuring while generating │
│ │ an assembler listing file could cause a compile-time │
│ │ general protection fault. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ PJ08753 │ RT Problem: When flushing a buffer of size greater than │
│ │ 8192 (8K) bytes and the buffer contains no LF, the library│
│ │ will trap with a General Protection fault. This usually │
│ │ happens when the user sets the buffer size using setvbuf │
│ │ to a value greater than 8192. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ RT Problem: Function _getdcwd incorrectly returns NULL │
│ │ and sets errno to 60 when the pointer passed to _getdcwd │
│ │ function as the second parameter is NULL. │
├───────────────┼────────────────────────────────────────────────────────────┤
│ NOAPAR │ FE Problem: Front-end might fail unpredictably when │
│ │ /Fl or /L option is specified without source listing (/Ls)│
╞═══════════════╧════════════════════════════════════════════════════════════╡
│ │
│ All the fixes listed above were included in CS00050 │
│ │
╘════════════════════════════════════════════════════════════════════════════╛
