Abstract:
A method of using exception information for binary code. The method comprises: receiving exception information relating to an exception occurring during execution of binary code, the exception information including a code reference identifying a function executing while the exception occurred, and a line number for that function. The method also comprises: accessing intermediate code using the code reference and the line number to obtain intermediate code fragments; converting the intermediate code fragments to a source code approximation; and providing the source code approximation and function name to a log for subsequent analysis.

Description:
FIELD OF INVENTION 
       [0001]    The present invention relates to improvements in or relating to using exception information. 
       BACKGROUND OF INVENTION 
       [0002]    It is not uncommon for exceptions to occur in binary code (also referred to as executable code). An exception has been defined as an event that occurs during execution of a program that disrupts the normal flow of instructions during the execution of that program. 
         [0003]    These exceptions are handled by the operating system, which typically captures the location (or the function) in the binary code at which the exception occurs, together with some additional details about the exception that occurred, for example, the stack trace, register values, the name of the application or object that caused the error, and the like. The operating system then searches through the list of methods that have already been called (the call stack) to search for a routine that can handle the exception. This routine is referred to as the exception handler. If no exception handler is found, then the operating system (if configured to do so) may launch a debugging application and provide the exception to that debugging application. Regardless of whether a debugging application is launched, the operating system will typically log the exception to an event log. 
         [0004]    Binary code is typically generated from source code (which is compiled to create the binary code). During this compilation process, useful information is lost. This lost information includes, for example, the names of the functions in the source code, the location of these functions in memory, the types of parameters expected by each function, global and local variable names, source code line information (which allows each command in binary code to be mapped back to one or more lines of source code associated with that command), and the like. 
         [0005]    Some programming environments (such as the Microsoft (trade mark) .NET framework, and Java (trade mark)) create intermediate code that is compiled at runtime to create binary code. For such programming environments, significantly more information is available to the target computer system executing the code at runtime than just the binary code. The collection of files that contain the intermediate code is typically referred to as an assembly. 
         [0006]    It remains, however, a difficult and time-consuming task to trace an exception to the original source code, even using these additional files. It would be better if this process could be improved. 
       SUMMARY OF INVENTION 
       [0007]    Accordingly, the invention generally provides methods, systems, and software for using exception information for binary code to attempt to re-create the source code that caused the exception. 
         [0008]    In addition to the Summary of Invention provided above and the subject matter disclosed below in the Detailed Description, the following paragraphs of this section are intended to provide further basis for alternative claim language for possible use during prosecution of this application, if required. If this application is granted, some aspects may relate to claims added during prosecution of this application, other aspects may relate to claims deleted during prosecution, other aspects may relate to subject matter never claimed. Furthermore, the various aspects detailed hereinafter are independent of each other, except where stated otherwise. Any claim corresponding to one aspect should not be construed as incorporating any element or feature of the other aspects unless explicitly stated in that claim. 
         [0009]    According to a first aspect there is provided a method of using exception information for binary code, the method comprising: 
         [0010]    receiving exception information relating to an exception occurring during execution of binary code, the exception information including a code reference identifying a function executing while the exception occurred, and a location for that function; 
         [0011]    accessing intermediate code using the code reference and the location to obtain intermediate code fragments; 
         [0012]    converting the intermediate code fragments to a source code approximation; and 
         [0013]    providing the source code approximation and function name to a log for subsequent analysis. 
         [0014]    The step of receiving exception information may include receiving a MethodBase object. 
         [0015]    The location may comprise a line number. 
         [0016]    The step of accessing intermediate code may include accessing an assembly. The assembly may include code implemented according to a NET framework. Alternatively, the assembly may include code implemented according to the Java language. 
         [0017]    The step of accessing intermediate code may include using the MethodBase.GetMethodBody method. 
         [0018]    The step of converting the intermediate code fragments to a source code approximation may include implementing a process of reflection to retrieve information about the various classes, methods, and properties included in a particular assembly. 
         [0019]    The step of converting the intermediate code fragments to a source code approximation may include implementing .NET Reflector (trade mark) software, available from Red Gate of Newnham House, Cambridge Business Park, Cambridge, CB4 0WZ, UK. Any other convenient tool may be used to convert the intermediate code fragments to a source code approximation. For example, suitable tools include: IL disassembler from Microsoft Corporation (trade mark); C#Builder from Borland Corporation (trade mark); Anakrino (from Jay Freeman); DotNet-Reflection-Browser from Lesser-Software (trade mark). 
         [0020]    The step of providing the source code approximation and function name to a log for subsequent analysis may include providing the log to a remote system. 
         [0021]    The log can be used by a software engineer to ascertain what gave rise to the exception. By using the source code approximation, it is easier to identify the particular function involved. 
         [0022]    According to a second aspect there is provided a computer executing: (i) binary code, and (ii) a context provider programmed to: 
         [0023]    receive exception information relating to an exception occurring during execution of the binary code; 
         [0024]    extract from the exception information (a) a code reference identifying a function executing while the exception occurred, and (b) a location from the binary code corresponding to that function; 
         [0025]    access intermediate code using the code reference and the line number to obtain intermediate code fragments; 
         [0026]    convert the intermediate code fragments to a source code approximation; and 
         [0027]    provide the source code approximation and function name to a log for subsequent analysis. 
         [0028]    The context provider may include a disassembly tool for converting the intermediate code fragments to a source code approximation. 
         [0029]    The context provider may be operable to receive exception information relating to an exception occurring during execution of the binary code from an operating system. 
         [0030]    The location from the binary code corresponding to that function may comprise a line number. 
         [0031]    According to a third aspect there is provided a method of using exception information for binary code, the method comprising: 
         [0032]    receiving exception information relating to an exception occurring during execution of binary code, the exception information including a code reference identifying a function executing while the exception occurred, and a line number for that function; 
         [0033]    accessing source code using the code reference and the line number to obtain a source code fragment; and 
         [0034]    providing the source code fragment and function name to a log for subsequent analysis. 
         [0035]    This method may be useful where source code and binary code are both resident on the same computer. 
         [0036]    For clarity and simplicity of description, not all combinations of elements provided in the aspects recited above have been set forth expressly. Notwithstanding this, the skilled person will directly and unambiguously recognize that unless it is not technically possible, or it is explicitly stated to the contrary, the consistory clauses referring to one aspect are intended to apply mutatis mutandis as optional features of every other aspect to which those consistory clauses could possibly relate. 
         [0037]    These and other aspects will be apparent from the following specific description, given by way of example, with reference to the accompanying drawings. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0038]      FIG. 1  is a simplified block diagram illustrating a computer executing software components according to one embodiment of the present invention; and 
           [0039]      FIG. 2  is a flowchart illustrating steps performed by the software components of  FIG. 1 . 
       
    
    
     DETAILED DESCRIPTION 
       [0040]    Reference is first made to  FIG. 1 , which is a simplified block diagram illustrating a computer  10  executing software components according to one embodiment of the present invention. 
         [0041]    The hardware in the computer  10  is conventional, so will only be described briefly herein. 
         [0042]    The computer  10  comprises a processor  12  coupled to volatile memory (RAM)  14  by a system bus  16 . The processor  12  is also coupled, inter alia, to a video interface  20 , a non-volatile storage interface  22 , and a USB interface  24 . 
         [0043]    The video interface  20  is coupled to a display  30  for outputting information to a user. The non-volatile storage interface  22  is coupled to a disk drive  32  for permanent storage of data and instructions, and also to removable media players (not illustrated, but including a compact disc player and/or a digital versatile disc player). The USB interface  24  is coupled to a keyboard  40 , a mouse  42 , and any other desired hardware input devices (such as a writing tablet). 
         [0044]    The software components executing in the memory  14  will now be described. 
         [0045]    The memory  14  includes a conventional operating system kernel  50 . In this embodiment, the operating system  50  comprises the Windows XP (trade mark) operating system, available from Microsoft Corporation (trade mark). 
         [0046]    In addition to the many standard components included in the operating system (not shown for clarity) there is a conventional Windows exception detection component  52 . The exception detection component  52  stores exception information to an operating system event log  54 . 
         [0047]    The memory  14  also includes a runtime environment  60 . In this embodiment the runtime environment  60  implements the .NET framework. The runtime environment  60  includes an intermediate code assembly  62  (compiled from source code), a just-in-time compiler  64  for compiling and optimizing the intermediate code to create native code (binary code)  66 . During operation, if an exception occurs while the binary code  66  is executing, the binary code  66  creates an exception object  68 . 
         [0048]    The memory  14  also includes a context provider  70 . The context provider  70  includes a reflector component  72  and a code fragment log  74 , which is populated by the reflector component  72 . In this embodiment, the reflector component is based on a program called .NET Reflector (trade mark), and is available from Red Gate of Newnham House, Cambridge Business Park, Cambridge, CB4 0WZ, UK. 
         [0049]    The operation of the computer  10  will now be described with reference to  FIG. 2 , which is a flowchart illustrating the steps performed by the software components  50 , 60 , 70  in the computer  10  to implement an improved exception handling process  100 . 
         [0050]    Initially, the user launches the intermediate code assembly  62  (step  102 ). This causes the just-in-time compiler  64  to compile the assembly  62  (step  104 ) to create binary code (native executable code), and then the runtime environment  60  executes the binary code (step  106 ). 
         [0051]    In the same way as for conventional programs, the operating system  50  monitors for any exceptions that occur (step  108 ). If there is no exception, and the binary code  66  is still executing (step  110 ) then the binary code  66  continues to execute as normal. If the binary code  66  has completed, then the process  100  terminates (step  112 ) 
         [0052]    If an exception occurs during execution, then the binary code  66  creates an object (the exception object  68 ) (step  114 ) that contains information about the exception. 
         [0053]    In this embodiment, the .NET framework is used, and the exception object  68  includes a MethodBase object that exposes relevant information about the exception that was thrown. This information about the exception includes: a message that describes the current exception; a link to any help file associated with this exception; the exception instance that caused the exception; the name of the application or object in the binary code  66  that caused the exception; the method that threw the current exception (which is a code reference identifying a function executing in the binary code  66  while the exception occurred); and a string representation of the frames on the call stack at the time the exception was thrown. The frames on the call stack can be used to identify a line number for the function executing in the binary code  66  while the exception occurred. 
         [0054]    The exception detection component  52  is notified of the exception object  68  and examines the call stack in a conventional manner to ascertain which component will handle the exception (step  116 ). 
         [0055]    In this embodiment, the context provider  70  performs exception handling (or at least a portion of exception handling). The exception detection component  52  conveys the exception object  68  to the context provider  70  (step  118 ). 
         [0056]    The context provider  70  uses the code reference and the line number from the exception object  68  to access the intermediate code assembly  62  to obtain intermediate code fragments (step  120 ). In this embodiment, this is implemented by the context provider  70  calling the method MethodBase.GetMethodBody, which retrieves the intermediate code fragments. 
         [0057]    The context provider  70  passes the intermediate code fragments to the reflector component  72 , which converts these intermediate code fragments to source code (step  122 ). This source code may not be identical to the original source code that was used to create the intermediate code assembly  62 , but it is an approximation to that original source code. Hence, it is referred to herein as source code approximation. 
         [0058]    The reflector component  72  then writes the source code approximation, exception type, and function name to the code fragment log  74  (step  124 ). The reflector component  72  may also write additional information, if desired. This information may include, for example, date, time, DLLs that are loaded, stack trace information, computer name or IP address, or the like. 
         [0059]    The code fragment log  74  may be transferred (on request, or periodically) to a remote system. A software engineer (or a tester or support person) can then examine the code fragment log  74  (at the remote system) to review the exception type and source code approximation for analysis. 
         [0060]    If the software engineer has access to the original source code, then the source code approximation may be useful to help the engineer locate the relevant function. However, the source code approximation may be sufficient for the engineer&#39;s purposes, thereby saving the engineer the time that would have been spent in looking up the original source code. 
         [0061]    It should now be appreciated that where an intermediate language is used, an approximation to the source code can be provided together with an exception to give a software engineer (or an automated system) more information about the origin of the exception and the source code that may have given rise to the exception. 
         [0062]    Various modifications may be made to the above described embodiment within the scope of the invention, for example, in other embodiments, if the target computer (that is, the computer that is executing the binary code) has access to the original source code, then the context provider  70  may use the details from the exception object  68  to access the original source code directly. This has the advantage that the source code fragment produced is the actual source code, not an approximation to the source code. In such an embodiment, the runtime environment  60  may not require intermediate code (intermediate between source code and binary code) since the original source code is present. 
         [0063]    In other embodiments, the runtime environment  60  may implement a Java (trade mark) framework. 
         [0064]    In other embodiments, the exception object  68  may include different (or additional) information to that described above. 
         [0065]    In other embodiments, a different reflector component  72  may be used to access the intermediate code assembly  62  and approximate source code therefrom. 
         [0066]    The steps of the methods described herein may be carried out in any suitable order, or simultaneously where appropriate. The methods described herein may be performed by software in machine readable form on a tangible storage medium or as a propagating signal. 
         [0067]    The terms “comprising”, “including”, “incorporating”, and “having” are used herein to recite an open-ended list of one or more elements or steps, not a closed list. When such terms are used, those elements or steps recited in the list are not exclusive of other elements or steps that may be added to the list. 
         [0068]    Unless otherwise indicated by the context, the terms “a” and “an” are used herein to denote at least one of the elements, integers, steps, features, operations, or components mentioned thereafter, but do not exclude additional elements, integers, steps, features, operations, or components. 
         [0069]    The presence of broadening words and phrases such as “one or more,” “at least,” “but not limited to” or other similar phrases in some instances does not mean, and should not be construed as meaning, that the narrower case is intended or required in instances where such broadening phrases are not used.