US 8,631,395 B2Granted

Inter-procedural dead catch handler optimizations

AssigneeMicrosoft Corporation

InventorsPatrick Sathyanathan, Ten Tzen

Life of this patent

Estimating the term…

Abstract

Whole program analysis during a link time code generation part of compilation can be used to detect and eliminate dead catch handlers. If all catch handlers of a try clause in a computer program are found to be dead then the try clause can also be eliminated. Detection of dead catches can be automatic, using iterative propagation of the types of thrown exceptions from callee function to caller function from bottom to top in the call-graph and iterative propagation of the types of in-flight exceptions from caller function to callee function from top to bottom in the call-graph.

Claims15

Dependent claims

A system comprising:

at least one processor of a computing device;
a memory of the computing device;
and
at least one module loaded into the memory causing the at least one processor to:
for each function in a computer program:
receive intermediate representation from a compiler for a function:
capture summary information for the function, the summary information comprising:
a structure capturing nesting of try and catch statements within the function, the function comprising a plurality of regions;
for each region of the plurality of regions of the function, types of exceptions thrown by the region;
for each catch region of the plurality of regions of the function, types of exceptions caught by the catch region;
for each region of the plurality of regions of the function, an indicator that indicates that re-throw statements are found within the region;
for each region of the plurality of regions of the function, functions called by the region;
for each region of the plurality of regions of the function, an indicator that indicates that the region calls unknown functions or does not call unknown functions;
and
add the summary information to a call-graph node for the function;
and
at least one module loaded into the memory causing the at least one processor to:
compute a set of live exception types thrown by each function by iteratively propagating types of thrown exceptions from a callee function to a caller function in the call-graph in a bottom-up direction and propagating types of in-flight exceptions from a caller function to a callee function in the call-graph in a top-down direction until a fix point is reached;
attempt to match catch handlers of each function with a corresponding set of thrown exceptions;
identify a dead catch handler by failing to find a thrown exception of a type caught by the dead catch handler;
and
removing the identified dead catch handler, wherein in response to determining that all the catch handlers of a try statement of a try/catch block are dead, the try/catch block from the computer program is removed.

19 more elements

A method comprising:

for each function comprising a plurality of regions in a computer program:
building by a processor of a software development computer, a data structure capturing nesting of exception statements of a function;
adding to the data structure;
a set of types of exceptions thrown by each region of the plurality of regions of the function;
a set of types of exceptions caught by each catch region of the plurality of regions of the function;
an indicator that indicates presence or absence of re-throw statements within each region of the plurality of regions of the function;
functions called by each region of the plurality of regions of the function;
for each region of the plurality of regions of the function, an indicator that indicates that the region calls unknown functions or does not call unknown functions;
adding the data structure to a call-graph node for the function;
identifying dead code within the computer program by matching types of exceptions thrown by the function with types of exceptions caught by the catch handlers within the function, wherein unmatched catch handlers are determined to be dead, wherein an exception thrown from a callee function to a caller function is propagated from bottom to top in the call-graph and wherein an exception in-flight from a caller function to a callee function is propagated from top to bottom in the call-graph;
and
removing the dead code from the function, wherein in response to determining that all the catch handlers of a try/catch block are dead, removing the try/catch block from the computer program.

9 more elements

A computer-readable storage memory comprising computer-executable instructions which when executed cause at least one processor of a computing device to:

receive intermediate representation from a compiler front-end for a function:
capture summary information for the function from the intermediate representation, the summary information comprising:
a structure capturing nesting of try and catch statements within the function, types of exceptions thrown by the function, types of exceptions caught by catch handlers within the function, re-throw statements within the function and functions called by the function;
add the summary information to a call-graph for the function;
compute a set of live exception types thrown by each function by iteratively propagating types of thrown exceptions from a callee function to a caller function in the call-graph in a bottom-up direction and propagating types of in-flight exceptions from a caller function to a callee function in the call-graph in a top-down direction until a fixpoint is reached;
attempt to match catch handlers of each function with a corresponding set of thrown exceptions;
identify a dead catch handler by failing to find a thrown exception of a type caught by the dead catching handler;
and
delete the identified dead catch handler;
and
delete a try/catch block in response to determining that all the catch handlers of the try/catch block are dead.

8 more elements

Dependencies are inferred from the claim text.

patentgrep

Loading patent…

Abstract

A system comprising:

at least one processor of a computing device;
a memory of the computing device;
and
at least one module loaded into the memory causing the at least one processor to:
for each function in a computer program:
receive intermediate representation from a compiler for a function:
capture summary information for the function, the summary information comprising:
a structure capturing nesting of try and catch statements within the function, the function comprising a plurality of regions;
for each region of the plurality of regions of the function, types of exceptions thrown by the region;
for each catch region of the plurality of regions of the function, types of exceptions caught by the catch region;
for each region of the plurality of regions of the function, an indicator that indicates that re-throw statements are found within the region;
for each region of the plurality of regions of the function, functions called by the region;
for each region of the plurality of regions of the function, an indicator that indicates that the region calls unknown functions or does not call unknown functions;
and
add the summary information to a call-graph node for the function;
and
at least one module loaded into the memory causing the at least one processor to:
compute a set of live exception types thrown by each function by iteratively propagating types of thrown exceptions from a callee function to a caller function in the call-graph in a bottom-up direction and propagating types of in-flight exceptions from a caller function to a callee function in the call-graph in a top-down direction until a fix point is reached;
attempt to match catch handlers of each function with a corresponding set of thrown exceptions;
identify a dead catch handler by failing to find a thrown exception of a type caught by the dead catch handler;
and
removing the identified dead catch handler, wherein in response to determining that all the catch handlers of a try statement of a try/catch block are dead, the try/catch block from the computer program is removed.

19 more elements