INSTRUMENTING PROGRAM CODE

• US 20180260198A1
• Filed: 03/09/2017
• Published: 09/13/2018
• Est. Priority Date: 03/09/2017
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Inventors: HAMBY, JOHN LAWRENCE, JAYASWAL, MANISH KUMAR, CASEY, ANDREW MICHAEL, TSINGAUZ, ALEKSEY, MATOUSEK, TOMAS, LU, GEN, GOODING, TANNER EVAN, NAMBOODIRIPAD, GHANASHYAN CHANDRASEKHAR
• Granted Patent: US 10,809,985 B2
• Time in Patent Office: Days
• CPC Class Codes: G06F 8/42 Syntactic analysis
• CPC Class Codes: G06F 8/436 Semantic checking
• CPC Class Codes: G06F 8/443 Optimisation
• CPC Class Codes: G06F 8/447 Target code generation

Abstract

A compiler can instrument a program during the front end of compilation to collect data about runtime behavior when the program is executed. Instrumentation can occur during source language processing rather than later in the compilation chain. The instrumentation can occur in between semantic analysis and code generation. The instrumentation can occur in an instrumenting rewriting phase. The instrumentation can occur in a first lowering phase in which high level constructs in a programming language are rewritten as lower level constructs in intermediate representation (IR). The compiler can inject the instrumentation code at particular points in the source code based on specified language constructs in the source program. The types of instrumentation injected can be extended by providing additional information to the compiler at compilation time, without the need to reprogram the compiler.

Claims

1. An extensible compiler, configured to:

receive information identifying a programming language construct in a program;

receive instrumentation to be performed on the programming language construct in the program, such that the instrumentation for a particular compilation of the program is extended beyond a fixed set of predefined instrumentations hard-coded into the compiler without reprogramming the compiler; and

insert the instrumentation into an instrumented bound tree representing the program, the instrumented bound tree created by an instrumenting rewriter of the compiler.

2. The compiler of claim 1, wherein the instrumenting rewriter converts the programming language construct from a higher level construct in source code for the program to a lower level construct in intermediate representation.

3. The compiler of claim 1, wherein the instrumenting rewriter inserts the instrumentation into the instrumented bound tree during a source language processing phase of compilation.

4. The compiler of claim 1, wherein the instrumentation is inserted between a semantic analysis phase and a code generation phase of compilation.

5. The compiler of claim 1, wherein a programming language construct and an instrumentation for the programming language construct can be added to a set of instrumentation-eligible programming language constructs without reprogramming the compiler.

6. The compiler of claim 1, wherein the instrumentation collects information about characteristics of runtime behavior of the program.

7. The compiler of claim 1, wherein the information identifying a programming language construct in a program to be instrumented is received at compile time.

8. The compiler of claim 1, wherein the instrumentation to be performed on the programming language construct in the program is received at compile time.

10. The instrumenting rewriter of claim 1, wherein additional instrumentation-eligible programming language constructs can be identified without reprogramming the compiler.

9. (canceled)

11. A method of instrumenting code comprising:

receiving by a compiler for a particular compilation, instructions for instrumenting an identified programming language construct of a source code program;

inserting instrumentation for the identified programming language construct into code representing the program without reprogramming the compiler, such that the instrumentation for the particular compilation of the program is extended beyond a fixed set of predefined instrumentations hard-coded into the compiler;

generating an instrumented bound tree comprising the instrumented programming language construct.

12. The method of claim 11, wherein a set of instrumentation-eligible programming language constructs are extensible without reprogramming the compiler.

13. The method of claim 11, wherein the instrumentation performed is extensible without reprogramming the compiler.

14. The method of claim 11, wherein information locating the programming language construct in the source code program is captured.

15. The method of claim 11, further comprising rewriting the programming language construct in a lower form in the instrumented bound tree.

16. A device for instrumenting code during the front end of compilation, the device comprising:

a memory;

a processor, the processor configured to;

for a particular compilation of a source code program, rewrite a higher level programming language construct of a the source code program into a lower level construct in a representation of the source code program comprising intermediate representation (IR);

receive instructions for identifying the higher level programming language construct;

receive instructions for instrumenting the higher level programming language construct without reprogramming a compiler of the source code program, such that the instrumentation for the particular compilation of the source code program is extended beyond a fixed set of predefined instrumentations hard-coded into the compiler;

store a location of the higher level programming language construct in the source code program; and

instrument the lower level construct in the IR.

17. The device of claim 16, wherein a set of instrumentation-eligible programming language constructs is extensible without reprogramming the compiler.

18. The device of claim 16, wherein instrumentations performed on a programming language construct are extensible without reprogramming the compiler.

19. The device of claim 16, wherein the processor is further configured to:

create an instrumented bound tree during source language processing in a front end of a compilation process.

20. The device of claim 19, wherein the instrumented bound tree is a representation of the source code program in intermediate representation.