Method and apparatus for providing runtime checking features in a compiled programming development environment

• US 5,583,988 A
• Filed: 03/09/1994
• Issued: 12/10/1996
• Est. Priority Date: 03/09/1994
• Status: Expired due to Term

• Current Assignee: National Instruments Corporation (Emerson Electric Company)
• Original Assignee: National Instruments Corporation (Emerson Electric Company)
• Inventors: Crank, Erik, Bellin, Jon
• Primary Examiner(s): Beausoliel, Jr., Robert W.
• Assistant Examiner(s): Wright, Norman M.
• Application Number:
  US08/208,559
• Time in Patent Office: 1,007 Days
• Field of Search: 395/185.01, 395/183.02, 395/183.31, 395/183.11, 395/184.01, 395/185.21, 395/183.13, 395/183.14, 364/267.91
• US Class Current: 714/48
• CPC Class Codes: G06F 11/3612 by runtime analysis performance monitoring G06F11/3466
• CPC Class Codes: G06F 11/3624 by performing operations on the source code, e.g. via a compiler

Abstract

A method and apparatus for performing runtime checking during program execution in a compiled environment using the full ANSI-C programming language. The present invention detects a number of errors during runtime that cannot be found by a compiler at the precise moment that a respective C language restriction is violated. The present invention also provides the user with a direct indication of the problem, thus saving debugging time. The runtime checking features of the present invention further detects when a user is using library functions improperly. When C source code is compiled, the present invention allocates special data structures for every pointer, array and structure object in the program. An association is made between each of these objects, and its special data structure in the compiler symbol table. At runtime, these data structures contain status information about their associated objects. The present invention also inserts special machine language instructions for C expressions during compilation that either modify values in the special data structures or call internal runtime checking functions according to the present invention that use the information in the respective data structures to determine whether an expression is illegal and report errors if necessary. The runtime checking features of the present invention include a method for specifying precise restrictions on the arguments that may be passed to library functions. These restrictions are used to determine whether arguments to library functions conform to their respective restrictions and reports any violations to the user at runtime, indicating which argument caused the error and which restriction was violated.

Claims

1. A method for performing runtime checking operations in a compiled programming development environment, comprising the steps of:

a) compiling a source code file into executable object code comprising machine language instructions, wherein said source code file includes aggregate data items and pointers and also includes expressions which manipulate said aggregate data items and pointers, wherein said step of compiling comprises;

creating data structures for aggregate data items and pointers in the source code file; and

inserting calls to runtime checking functions for one or more expressions in the source code file which manipulate said aggregate data items and pointers; and

b) executing the executable object code, wherein said step of executing comprises;

executing one or more of said runtime checking functions to determine if invalid operations occur in said expressions which manipulate said aggregate data items and pointers; and

reporting an error to the user if an invalid operation is found to occur after said step of executing one or more of said runtime checking functions.

2. The method of claim 1, wherein said step of executing the executable object code further comprises:

executing said expressions which manipulate said aggregate data items and pointers if an invalid operation does not occur in said respective expressions in said step of executing one or more of said runtime checking functions.

3. The method of claim 1, wherein said step of executing said runtime checking functions comprises accessing said data structures and utilizing information in said data structures.

4. The method of claim 1, wherein said step of compiling further comprises:

inserting instructions in said executable object code which modify values in one or more of said data structures;

wherein said step of executing the executable object code further comprises executing said instructions which modify values in said one or more of said data structures.

5. The method of claim 1, wherein said step of compiling further comprises:

inserting instructions in said executable object code which modify values in one or more of said data structures in response to expressions in said source code file which manipulate said aggregate data items and pointers;

wherein said step of executing the executable object code further comprises executing said instructions which modify values in said one or more of said data structures to update information in said data structures in accordance with said expressions in said source code file which manipulate said aggregate data items and pointers.

6. The method of claim 1, wherein said step of reporting an error comprises providing information on the location in the source code file of the violation causing the error.

7. The method of claim 6, wherein said step of compiling the source code file comprises generating information about the location of said expressions which manipulate said aggregate data items and pointers;

wherein said step of reporting an error uses said location information to provide information on the location in the source code file of the violation causing the error.

8. The method of claim 1, wherein said step of executing the executable object code comprises updating a data structure comprising current runtime information;

and

wherein said current runtime information data structure comprises information regarding the current function being executed.

9. The method of claim 1, wherein said step of creating data structures for aggregate data items and pointers comprises:

creating a Block Info data structure for each of a plurality of aggregate data items in the source code file, wherein said Block Info data structure comprises information regarding the beginning of the respective aggregate data item and the size of the respective aggregate data item.

10. The method of claim 1, wherein said step of creating data structures for aggregate data items and pointers comprises:

creating a Pointer Info data structure for each of a plurality of pointers in the source code file, wherein said Pointer Info data structure comprises information regarding the object to which said respective pointer points.

11. The method of claim 1, wherein said aggregate data items comprise arrays.

12. The method of claim 1, wherein said aggregate data items comprise structures and arrays.

13. The method of claim 1, wherein one or more data structures associated with respective one or more pointers include information regarding the type of object to which said respective pointer points;

wherein said step of executing said runtime checking functions comprises;

accessing a data structure associated with a pointer; and

determining if said object type information in said data structure associated with said pointer corresponds to the type of said pointer;

wherein said step of reporting an error includes reporting an error if said object type information in said data structure associated with said pointer does not correspond to the type of said pointer.

14. The method of claim 1, wherein said step of executing the executable object code comprises:

accessing a data structure associated with a pointer;

determining if said data structure associated with said pointer indicates that runtime checking functions for said pointer should be ignored;

not performing runtime checking functions for said pointer if said data structure indicates said runtime checking functions for said pointer should be ignored.

15. The method of claim 1, wherein said step of executing said runtime checking functions comprises:

accessing a data structure associated with a pointer; and

determining if said data structure associated with said pointer indicates that said pointer is uninitialized;

wherein said step of reporting an error includes reporting an error if said data structure indicates said pointer is uninitialized.

16. The method of claim 1, wherein said step of executing the runtime checking functions comprises:

accessing a data structure associated with a pointer; and

determining if said data structure associated with said pointer indicates that said pointer is invalid;

wherein said step of reporting an error includes reporting an error if said data structure indicates said pointer is invalid.

17. The method of claim 1, wherein said step of executing said runtime checking functions comprises:

accessing a data structure associated with a pointer; and

determining if said data structure associated with said pointer indicates that said pointer has a null value;

wherein said step of reporting an error includes reporting an error if said data structure indicates said pointer has a null value.

18. The method of claim 1, wherein one or more data structures associated with respective one or more pointers include information regarding the type of object to which said respective pointer points;

wherein said step of executing said runtime checking functions comprises;

accessing a data structure associated with a pointer;

determining if said pointer points to an aggregate data item; and

determining if said aggregate data item pointed to by said pointer resides in a deallocated block of memory if said pointer points to an aggregate data item;

wherein said step of reporting an error includes reporting an error if said aggregate data item pointed to by said pointer resides in a deallocated block of memory.

19. The method of claim 18, wherein said step of determining if said aggregate data item pointed to by said pointer resides in a deallocated block of memory comprises accessing a data structure associated with said aggregate data item to determine if said aggregate data item resides in a deallocated block of memory.

20. The method of claim 1, wherein one or more data structures associated with respective one or more pointers include information regarding the type of object to which said respective pointer points;

wherein said step of executing said runtime checking functions comprises;

accessing a data structure associated with a pointer, wherein said pointer is included in an expression that produces a result;

determining if said pointer points to an aggregate data item;

determining if said result of said pointer expression is within the bounds of said aggregate data item if said pointer points to an aggregate data item;

reporting an error if the result of said pointer expression is not within said bounds of said aggregate data item.

21. The method of claim 1, wherein one or more data structures associated with respective one or more pointers include information regarding the type of object to which said respective pointer points;

wherein said step of executing said runtime checking functions comprises;

determining if said object type information in said data structure associated with said pointer corresponds to the type of said pointer;

determining if said pointer points to an object other than a non-aggregate data item; and

determining if said pointer points two bytes beyond or one byte before said non-aggregate object if said pointer points to an object other than a non-aggregate data item;

wherein said step of reporting an error includes reporting an error if said pointer points two bytes beyond or one byte before said non-aggregate object.

22. The method of claim 1, wherein said step of executing said runtime checking functions comprises:

accessing data structures of first and second pointers on left and right respective sides of a pointer assignment expression;

determining if said first pointer includes a pointer data structure; and

copying the pointer data structure from said second pointer to said first pointer if said first pointer includes pointer information.

23. The method of claim 1, wherein said step of executing said runtime checking functions comprises:

accessing data structures of first and second pointers included in a pointer comparison expression; and

determining if said first and second pointers point to the same object;

wherein said step of reporting an error includes reporting an error if said first and second pointers do not point to the same object.

24. The method of claim 1, wherein said step of executing said runtime checking functions comprises:

accessing data structures of first and second pointers included in a pointer subtraction expression; and

determining if said first and second pointers point to the same object;

wherein said step of reporting an error comprises reporting an error if said first and second pointers do not point to the same object.

25. The method of claim 1, wherein said step of executing the executable object code comprises:

accessing one or more data structures for pointers and aggregate data items in arguments being passed from a caller function to a callee function;

placing said one or more data structures into a current runtime information data structure;

beginning execution of said callee function; and

accessing said one or more data structures from said current runtime information data structure inside said callee function to perform runtime checking operations on expressions inside said callee function.

26. The method of claim 25, wherein said step of executing said runtime checking functions further comprises:

said callee function generating a return value comprising a pointer or aggregate data item;

placing the address of said callee function in the current runtime information data structure;

said callee function returning said return value;

comparing the address of said callee function and the value stored in said current runtime information data structure;

placing an ignore value in a data structure associated with said return value if the address of said callee function does not match said value stored in said current runtime information data structure;

accessing information in said return value data structure if the address of said callee function matches said value stored in said current runtime information data structure.

27. The method of claim 1, wherein the source code file includes an expression that references a pointer;

wherein said step of executing said runtime checking functions comprises;

comparing the value of said pointer and a value stored in the data structure associated with said pointer;

determining if said values correspond; and

placing an ignore value in said pointer data structure if said values do not correspond.

28. The method of claim 1, wherein said step of reporting an error comprises reporting either a fatal error or a non-fatal error, said step of executing the executable file further comprising:

discontinuing operation of said step of executing the executable file if a fatal error is reported in said step of reporting an error.

29. The method of claim 28, wherein said step of executing the executable object code further comprises:

continuing operation of said step of executing the executable object code if a non-fatal error is reported in said step of reporting an error.

30. The method of claim 1, further comprising:

linking said executable object code with externally compiled object code to create linked object code after said step of compiling;

wherein said step of executing the executable object code comprises executing said linked executable object code.

31. The method of claim 1, wherein said step of executing the executable object code further comprises:

dynamically allocating an object in dynamic memory; and

creating one or more data structures for said dynamically allocated object.

32. The method of claim 31, wherein said step of executing the executable object code further comprises:

executing one or more of said runtime checking functions to determine if invalid operations occur in expressions which manipulate said dynamically allocated object; and

wherein said step of reporting comprises reporting an error if an invalid operation is found to occur in said step of executing one or more of said runtime checking functions.

33. The method of claim 31, wherein said step of executing the executable object code comprises:

monitoring cast expressions in said source code file to determine the type of said dynamically allocated object; and

updating said data structure for said dynamically allocated object with said type information.

34. The method of claim 31, wherein said step of executing the executable object code further comprises:

monitoring a pointer into dynamic memory being cast to a non-void type;

recording said non-void type information into said one or more data structures;

creating one or more additional data structures if said non-void type is an aggregate data item.

35. The method of claim 31, wherein said step of executing said runtime checking functions comprises:

executing an expression including a pointer cast expression that casts a pointer to an object of X type to a pointer to an object of Y type;

determining if X is void and said pointer to said object of X type is a pointer to a dynamically created object;

determining if there is sufficient memory for said cast operation to occur if X is void and said pointer to said object of X type is a pointer to a dynamically created object;

reporting an error if there is insufficient space for said cast operation to occur.

36. A method for performing runtime checking on arguments passed to external libraries in a compiled programming environment, comprising the steps of:

inserting argument restrictions into a source code file;

generating argument runtime checking code based on said inserted argument restrictions;

linking said argument runtime checking code to a library;

executing a program which includes one or more calls to functions in said library, wherein said one or more calls to said functions in said library pass one or more arguments to said functions in said library;

executing said argument runtime checking code to determine if said one or more arguments passed to said functions in said library violate said argument restrictions;

reporting an error if said one or more arguments passed to said functions in said library violate said argument restrictions.

37. The method of claim 36, wherein said step of generating comprises generating argument runtime checking source code;

wherein said step of linking comprises linking said argument runtime checking source code with source code of said library to generate linked library source code;

the method further comprising;

compiling said linked library source code into a library object code file;

wherein said step of executing said argument runtime checking code comprises executing said compiled argument runtime checking code in said library object code file.

38. The method of claim 36, wherein said step of generating comprises generating argument runtime checking object code;

and

wherein said step of linking comprises linking said argument runtime checking object code with object code of said library.

39. The method of claim 36, wherein said step of inserting comprises inserting argument restrictions into a source code file of said library.

40. The method of claim 36, wherein said source code file includes declarations of said functions in said library.

41. A method for performing runtime checking operations in a compiled programming environment, comprising the steps of:

a) compiling a first number of source code files into unlinked object code files comprising machine language instructions, wherein said first number of source code files includes aggregate data items and pointers and also includes expressions which manipulate said aggregate data items and pointers, wherein said step of compiling comprises;

creating runtime checking data structures for aggregate data items and pointers in said first number of source code files; and

inserting calls to runtime checking functions for one or more expressions in said first number of source code files which manipulate said aggregate data items and pointers;

b) compiling a second number of source code files into unlinked external object code files, wherein said step of compiling said second number of source code files into unlinked external object code files does not include said steps of creating runtime checking data structures or inserting calls to runtime checking functions;

c) linking said unlinked object code files and said unlinked external object code files into a plurality of linked object code executable files; and

d) executing said plurality of linked object code executable files, wherein said step of executing comprises;

executing one or more of said runtime checking functions to determine if invalid operations occur in said expressions which manipulate said aggregate data items and pointers; and

reporting an error to the user if an invalid operation is found to occur alter said step of executing one or more of said runtime checking functions.

42. The method of claim 41, wherein said step of linking comprises:

receiving an identifier comprised in an expression in an unlinked object code file;

determining if the definition of said identifier resides in an unlinked object code file that was compiled by the compiler of step (a);

determining the address of a data structure associated with said identifier if the definition of said identifier resides in an unlinked object code file that was compiled by the compiler of step (a); and

associating said address of said data structure with said identifier.

43. The method of claim 41, wherein said step of linking comprises:

receiving an identifier comprised in an expression in an unlinked object code file;

determining if the definition of said identifier resides in an unlinked object code file that was compiled by the compiler of step (a);

associating an ignore value with said identifier if the definition of said identifier resides in an unlinked object code file that was not compiled by the compiler of step (a).

44. A method for performing runtime checking operations in a compiled programming development environment, comprising the steps of:

a) compiling a source code file into executable object code comprising machine language instructions, wherein said source code file includes pointers and also includes expressions which manipulate said pointers, wherein said step of compiling comprises;

creating data structures for pointers in the source code file; and

inserting calls to runtime checking functions for one or more expressions in the source code file which manipulate said pointers; and

b) executing the executable object code, wherein said step of executing comprises;

executing one or more of said runtime checking functions to determine if invalid operations occur in said expressions which manipulate said pointers; and

reporting an error to the user if an invalid operation is found to occur after said step of executing one or more of said runtime checking functions.

45. An apparatus for performing runtime checking operations in a compiled programming development environment, comprising:

a compiler which compiles a source code file into executable object code comprising machine language instructions, wherein said source code file includes aggregate data items and pointers and also includes expressions which manipulate said aggregate data items and pointers, wherein said compiler creates data structures for aggregate data items and pointers in the source code file and inserts calls to runtime checking functions for one or more expressions in the source code file which manipulate said aggregate data items and pointers; and

means for executing the executable object code, wherein said means executes one or more of said runtime checking functions to determine if invalid operations occur in said expressions which manipulate said aggregate data items and pointers and reports an error to the user if an invalid operation is found to occur after executing one or more of said runtime checking functions, wherein said means for executing accesses one or more of said data structures in executing said runtime checking functions.