Stack unique signatures for program procedures and methods

• US 7,873,954 B2
• Filed: 05/12/2006
• Issued: 01/18/2011
• Est. Priority Date: 02/03/2000
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Wynn, Allen Chester, Ullmann, Lorin
• Primary Examiner(s): VU, TUAN A
• Application Number:
  US11/433,681
• Publication Number:
  US 20060206875A1
• Time in Patent Office: 1,712 Days
• Field of Search: 717128-130, 717/136, 717159-160, 370/389, 370/396, 370/401, 370/392, 711/1, 711/220, 711/170, 712/233, 712/225, 712/202, 712/244, 271/178, 271/3.12
• US Class Current: 717/160
• CPC Class Codes: G06F 2209/481 Exception handling
• CPC Class Codes: G06F 9/4484 Executing subprograms
• CPC Class Codes: G06F 9/4486 Formation of subprogram jump address

Abstract

Stack signature marking segments are inserted into re-entrant programming source code modules prior to compilation of the modules at each code module entry point and at each code module exit point, followed by producing one or more executable programs from the programming source code modules. Upon execution of instances of the executable programs, the inserted segments assign unique, non-duplicated module identifier values to the instances of the code modules, generate an instance count for each instantiation of executable code module in the stack signature for each object instance dynamically created during runtime of a re-entrant executable code module, and push onto a processing stack the module identifier values and the instance counts within stack frames allocated to each of the executable program instances.

Claims

1. An automated method comprising:

inserting stack signature marking segment program instructions into one or more re-entrant programming source code modules stored in a computer-readable storage memory, the stack signature marking segment program instructions being inserted prior to compilation of the programming source code modules at each code module entry point and at each code module exit point;

producing one or more executable programs in a computer-readable storage memory from the programming source code modules having the inserted stack signature marking segment program instructions;

upon execution of instances of the executable programs;

assigning unique, non-duplicated module identifier values to the instances of the code modules by the stack signature marking segment program instructions, and

generating an instance count for each instantiation of executable code module in the stack signature for each object instance dynamically created during runtime of a re-entrant executable code module;

pushing by the executed programs by a processor onto a processing stack stored in a computer-readable storage memory the module identifier values and the instance counts within stack frames allocated to each of the executable program instances.

2. The automated method as set forth in claim 1 further comprising pushing onto the stack an entry/exit indicator associated with the unique module identifier.

3. The automated method as set forth in claim 1 further comprising providing a global control which enables insertion of stack signature marking segment program instructions into all application source code modules.

4. The automated method as set forth in claim 1 further comprising providing a selective control which enables insertion of stack signature marking segment program instructions into only certain application source code modules.

5. The automated method as set forth in claim 1 further comprising encrypting at least a portion of the identifier values.

6. The automated method as set forth in claim 1 further comprising encrypting an instance number in the identifier values.

7. The automated method as set forth in claim 1 wherein pushing identifiers onto a processing stack comprises:

generating a pseudo-random identifier for each object instance dynamically created during runtime of a re-entrant executable code module; and

including the pseudo-random identifier in the identifier pushed onto the processing stack.

8. A computer program product comprising:

a computer readable storage memory suitable for storing or encoding computer programs;

first computer instructions for inserting stack signature marking segment program instructions into one or more re-entrant programming source code modules stored in a computer-readable storage memory, the stack signature marking segment program instructions being inserted prior to compilation of the programming source code modules at each code module entry point and at each code module exit point;

second computer instructions for producing one or more executable programs in a computer-readable storage memory from the programming source code modules having the inserted stack signature marking segment program instructions; and

third computer instructions for, upon execution of instances of the executable programs;

assigning unique, non-duplicated module identifier values to the instances of the code modules by the stack signature marking segment program instructions,

generating an instance count for each instantiation of executable code module in the stack signature for each object instance dynamically created during runtime of a re-entrant executable code module, and

pushing by the executed programs by a processor onto a processing stack stored in a computer-readable storage memory the module identifier values and the instance counts within stack frames allocated to each of the executable program instance;

wherein the first, second and third computer instructions are stored by the computer readable storage memory.

9. The computer readable storage memory device as set forth in claim 8 further comprising fifth program instructions for pushing onto the stack an entry/exit indicator associated with the unique module identifier, wherein the fifth computer instruction is stored by the computer readable storage memory.

10. The computer readable storage memory device as set forth in claim 8 further comprising fifth program instructions for providing a global control to enable insertion of stack signature marking segment program instructions into all application source code modules, wherein the fifth computer instruction is stored by the computer readable storage memory.

11. The computer readable storage memory device as set forth in claim 8 further comprising fifth program instructions for providing a selective control to enable insertion of stack signature marking segment program instructions into only certain application source code modules, wherein the fifth computer instruction is stored by the computer readable storage memory.

12. A system comprising:

a computer system having a processor and one or more computer readable storage memory devices;

a control portion of the computer system operable by a user to enable insertion of stack signature marking program code segments into re-entrant application program source code modules at each entry point and each exit point of the application program modules;

a code inserter portion of the computer system which, responsive to the operation of the control, searches for entry points and exits points in application program source code modules, and inserts modules stack signature marking code segments following each entry point and prior to each exit point into un-compiled source code of the application program modules;

a compiler which produces one or more executable programs from the application source code program modules having the inserted stack signature marking code segments; and

a debugger which, upon execution of the compiled executable programs including the stack signature marking code segments, assigns unique and non-duplicated module identifier values to each instance of the code modules by the signature marking code segments, generates an instance count for each instantiation of executable code module in the stack signature for each object instance dynamically created during runtime of a re-entrant executable code module, and pushes the module identifiers and instance counts onto a processing stack within stack frames allocated to the instances of the modules.

13. The system of claim 12 wherein the control comprises a global control for indicating insertion of stack signature marking code segments are to be inserted into all application program modules to be compiled.

14. The system of claim 12 wherein the control means comprises a selective control for indicating specific application program modules or groups of application program modules into which stack signature marking code segments are to be inserted.