US20090133005A1 - Method for validation of binary code transformations - Google Patents

Method for validation of binary code transformations Download PDF

Info

Publication number
US20090133005A1
US20090133005A1 US12/206,578 US20657808A US2009133005A1 US 20090133005 A1 US20090133005 A1 US 20090133005A1 US 20657808 A US20657808 A US 20657808A US 2009133005 A1 US2009133005 A1 US 2009133005A1
Authority
US
United States
Prior art keywords
program
sequence
control flow
linear function
invariant linear
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US12/206,578
Inventor
Yaakov Yaari
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
International Business Machines Corp
Original Assignee
International Business Machines Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by International Business Machines Corp filed Critical International Business Machines Corp
Priority to US12/206,578 priority Critical patent/US20090133005A1/en
Publication of US20090133005A1 publication Critical patent/US20090133005A1/en
Abandoned legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/44—Encoding
    • G06F8/443—Optimisation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/70—Software maintenance or management
    • G06F8/75—Structural analysis for program understanding

Definitions

  • the present disclosure relates to optimizing computer executable codes, and particularly to a method for validating binary code transformation.
  • Optimizing executable code is a known technique to improve the performance of code that has already been linked and is ready for execution. It is typically performed using a runtime profile of the code. Different optimization techniques are available such as inlining and code restructuring, which transform the code to functionally equivalent form. If the code optimization does not correctly transform the code to functionally equivalent form, unpredictable consequences may result, such as a program crash.
  • the method may comprise analyzing binary code of an executable program to produce a sequence of basic units; generating control flow graph associated with the sequence of basic units; generating invariant linear function representation based on the control flow graph; analyzing optimized transformation of the executable program to produce a second sequence of basic units; generating second control flow graph associated with the second sequence of basic units; generating second invariant linear function representation based on the second control flow graph; comparing the invariant linear function representation and the second invariant linear function representation; and identifying one or more incorrect transformations in the optimized transformation.
  • a program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform the above method may also be provided.
  • FIG. 1 is a flow diagram illustrating a method for validating binary code transformation in one embodiment of the present disclosure.
  • FIG. 2 shows an example sequence of three basic blocks.
  • FIG. 3 shows the FCG for the basic blocks in FIG. 2 .
  • the binary code of the original program and the transformed program are analyzed, using various available techniques such as static techniques using relocation information and/or dynamic techniques by intercepting execution and recognizing the accessed basic units, and a control flow graph for both programs is generated. For each validated function, the two graphs are both traversed in consistent fashion, creating their linear invariant textual representations. These linear representations can be compared as simple text strings in order to identify incorrect transformation.
  • FIG. 1 is a flow diagram illustrating a method for validating binary code transformation in one embodiment of the present disclosure. Steps 102 , 104 and 106 are performed for both the original and the transformed codes.
  • program analysis begins.
  • the executable program is analyzed using the FDPR (Feedback Directed Program Restructuring) technology. Briefly, FDPR optimizes the executable image of a program by collecting information on the behavior of the program while the program is used for some typical workload, and then creating a new version of the program that is optimized for that workload.
  • the principal output of this analysis is a sequence of basic units. Basic units are the smallest elements of the program that stay intact under every reordering. In this embodiment of the disclosure, the basic units include two types, basic blocks and data objects.
  • the basic blocks type includes instructions.
  • the data objects type includes data, for example, read-only and writable.
  • Data objects correspond to the high-level data objects defined in the source program, for examples arrays, structures, or scalars.
  • a basic block is a sequence of instructions that can be entered only at its beginning and exited only at its end.
  • FIG. 2 shows an example sequence of three basic blocks 202 , 204 , 206 , of which two 202 , 204 are adjacent.
  • building a program control flow graph begins.
  • building the CFG is done by connecting, with a directed edge, the exit point of each basic block A to the entry points of the basic blocks according to the way A terminates. For instance, if A terminates by a simple branch, connect to the target of the branch. If A terminates by a conditional branch, connect to both the target of the branch, as well as the following basic block (called the fall-through basic block). If A terminates by an indirect branch keep A unconnected at the moment, as the target is not known at this moment.
  • FIG. 3 shows the CFG for the basic blocks in FIG. 2 .
  • An edge in the CFG carries an execution count, that is, the number of times control passed along that edge when the program was executed. This information can be collected by various means, for example, the “pixie” tool, or the basic block profiling provided by standard compilers like GCC.
  • An edge that carries relatively high execution count is termed hot edge.
  • a basic block that executes many times relative to the average count is termed hot basic block.
  • invariant linear function representation is created by consistently traversing the CFC. This step forms an invariant linear representation for a given function.
  • Invariant representation refers to one or more invariants under a set of predefined optimization transformations of the function.
  • An optimization transformation is a transformation of the code that preserves the semantics of the function while providing some potential improvement, typically in execution time.
  • the basic set of transformations includes at least code restructuring, function inlining, and hot-cold code motion.
  • Code restructuring is an optimization, which places basic blocks close to each other if they are connected by relatively hot edges. For example, basic block A (shown in FIG. 2 and FIG. 3 ) ends with a BNE branch (branch of not equal), following basic block B, for the EQ condition. Under code restructuring, if the edge A-C is much hotter then A-B, the condition that ends A might be changed to EQ (that is, BEQ) so that basic block C will be the fall-through basic block A. Similarly, basic blocks that connect by edges with cold branches may be placed far from each other, sometimes requiring an additional intermediate branch in between if the distance is too great for the original branch to be performed in one hop.
  • Hot-cold code motion optimization moves instructions from hot basic block to a colder one, making sure these instructions are properly replicated to preserve the semantics.
  • the following algorithm is used to create an invariant linear representation of a function in one embodiment.
  • the representation is in a form of a sequence of strips.
  • a strip is a possible path through the program CFG, that is, a trace of non-branch instructions that may execute sequentially when the program runs.
  • the generated strips of two implementations of a function are compared.
  • the comparison can be a textual or character-by-character comparison. Incorrect transformations are identified from the comparison. For example, the strip or strips corresponding to the transformed or optimized code that do not match the strip or strips of the original code are identified as being incorrect.
  • the system and method of the present disclosure may be implemented and run on a general-purpose computer or computer system.
  • the computer system may be any type of known or will be known systems and may typically include a processor, memory device, a storage device, input/output devices, internal buses, and/or a communications interface for communicating with other computer systems in conjunction with communication hardware and software, etc.
  • the terms “computer system” and “computer network” as may be used in the present application may include a variety of combinations of fixed and/or portable computer hardware, software, peripherals, and storage devices.
  • the computer system may include a plurality of individual components that are networked or otherwise linked to perform collaboratively, or may include one or more stand-alone components.
  • the hardware and software components of the computer system of the present application may include and may be included within fixed and portable devices such as desktop, laptop, and server.
  • a module may be a component of a device, software, program, or system that implements some “functionality”, which can be embodied as software, hardware, firmware, electronic circuitry, or etc.

Abstract

A method of validating binary code transformation in one aspect includes analyzing original program and transform program. Control flow graphs are generated for both programs. The two graphs are traversed to create respective linear invariant representations. The linear representations are compared to identify incorrect transformations.

Description

    CROSS-REFERENCE TO RELATED APPLICATIONS
  • This application is a continuation of U.S. patent application Ser. No. 11/940,750 filed on Nov. 15, 2007.
    • FIELD OF THE INVENTION
  • The present disclosure relates to optimizing computer executable codes, and particularly to a method for validating binary code transformation.
    • BACKGROUND OF THE INVENTION
  • Optimizing executable code is a known technique to improve the performance of code that has already been linked and is ready for execution. It is typically performed using a runtime profile of the code. Different optimization techniques are available such as inlining and code restructuring, which transform the code to functionally equivalent form. If the code optimization does not correctly transform the code to functionally equivalent form, unpredictable consequences may result, such as a program crash.
  • While there are existing technologies that perform validations on program source code, semantics of compiler's internal representation of a code, or even hardware level code, those technologies are incapable of handling the kind of transformations performed on the binary applications. Thus, what is desirable is a method that helps to validate the correctness of binary code transformations.
    • BRIEF SUMMARY OF THE INVENTION
  • A method for validating binary code transformations is provided In one aspect, the method may comprise analyzing binary code of an executable program to produce a sequence of basic units; generating control flow graph associated with the sequence of basic units; generating invariant linear function representation based on the control flow graph; analyzing optimized transformation of the executable program to produce a second sequence of basic units; generating second control flow graph associated with the second sequence of basic units; generating second invariant linear function representation based on the second control flow graph; comparing the invariant linear function representation and the second invariant linear function representation; and identifying one or more incorrect transformations in the optimized transformation.
  • A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform the above method may also be provided.
  • Further features as well as the structure and operation of various embodiments are described in detail below with reference to the accompanying drawings. In the drawings, like reference numbers indicate identical or functionally similar elements.
    • BRIEF DESCRIPTION OF THE DRAWINGS
  • FIG. 1 is a flow diagram illustrating a method for validating binary code transformation in one embodiment of the present disclosure.
  • FIG. 2 shows an example sequence of three basic blocks.
  • FIG. 3 shows the FCG for the basic blocks in FIG. 2.
    •  DETAILED DESCRIPTION
  • The binary code of the original program and the transformed program are analyzed, using various available techniques such as static techniques using relocation information and/or dynamic techniques by intercepting execution and recognizing the accessed basic units, and a control flow graph for both programs is generated. For each validated function, the two graphs are both traversed in consistent fashion, creating their linear invariant textual representations. These linear representations can be compared as simple text strings in order to identify incorrect transformation.
  • FIG. 1 is a flow diagram illustrating a method for validating binary code transformation in one embodiment of the present disclosure. Steps 102, 104 and 106 are performed for both the original and the transformed codes. At 102, program analysis begins. The executable program is analyzed using the FDPR (Feedback Directed Program Restructuring) technology. Briefly, FDPR optimizes the executable image of a program by collecting information on the behavior of the program while the program is used for some typical workload, and then creating a new version of the program that is optimized for that workload. The principal output of this analysis is a sequence of basic units. Basic units are the smallest elements of the program that stay intact under every reordering. In this embodiment of the disclosure, the basic units include two types, basic blocks and data objects. The basic blocks type includes instructions. The data objects type includes data, for example, read-only and writable. Data objects correspond to the high-level data objects defined in the source program, for examples arrays, structures, or scalars. A basic block is a sequence of instructions that can be entered only at its beginning and exited only at its end. FIG. 2 shows an example sequence of three basic blocks 202, 204, 206, of which two 202, 204 are adjacent.
  • Referring back to FIG. 1, at 104, building a program control flow graph (CFG) begins. In one embodiment, building the CFG is done by connecting, with a directed edge, the exit point of each basic block A to the entry points of the basic blocks according to the way A terminates. For instance, if A terminates by a simple branch, connect to the target of the branch. If A terminates by a conditional branch, connect to both the target of the branch, as well as the following basic block (called the fall-through basic block). If A terminates by an indirect branch keep A unconnected at the moment, as the target is not known at this moment. FIG. 3 shows the CFG for the basic blocks in FIG. 2.
  • An edge in the CFG carries an execution count, that is, the number of times control passed along that edge when the program was executed. This information can be collected by various means, for example, the “pixie” tool, or the basic block profiling provided by standard compilers like GCC. An edge that carries relatively high execution count is termed hot edge. A basic block that executes many times relative to the average count is termed hot basic block.
  • Referring back to FIG. 1, at 106, invariant linear function representation is created by consistently traversing the CFC. This step forms an invariant linear representation for a given function. Invariant representation refers to one or more invariants under a set of predefined optimization transformations of the function. An optimization transformation is a transformation of the code that preserves the semantics of the function while providing some potential improvement, typically in execution time.
  • The basic set of transformations includes at least code restructuring, function inlining, and hot-cold code motion. Code restructuring is an optimization, which places basic blocks close to each other if they are connected by relatively hot edges. For example, basic block A (shown in FIG. 2 and FIG. 3) ends with a BNE branch (branch of not equal), following basic block B, for the EQ condition. Under code restructuring, if the edge A-C is much hotter then A-B, the condition that ends A might be changed to EQ (that is, BEQ) so that basic block C will be the fall-through basic block A. Similarly, basic blocks that connect by edges with cold branches may be placed far from each other, sometimes requiring an additional intermediate branch in between if the distance is too great for the original branch to be performed in one hop.
  • Function inlining replaces the call instruction by a copy of the fiction in places where the call instruction is very hot. Hot-cold code motion optimization moves instructions from hot basic block to a colder one, making sure these instructions are properly replicated to preserve the semantics.
  • The following algorithm is used to create an invariant linear representation of a function in one embodiment. The representation is in a form of a sequence of strips. A strip is a possible path through the program CFG, that is, a trace of non-branch instructions that may execute sequentially when the program runs.
  •
    Function CreateInvariantRepresentation (ControlFlowGraph cfg
    Function f)
      // Control Flow Graph cfgis the CFG of the program
      // Node f is the entry point of the give
      Stack returnStack= <empty> // a stack of nodes in cfg
      Stack entryPointStack = <empty> // a stack of nodes in cfg
      List stripList = <empty> // the output list of strips.
      Node epf = EntryPoint(f)
    Push(epf, entryPointStack)
      While entryPointStackis not empty do
        ep = Pop(entryPointStack)
        If ep has not been traversed then
          strip = Traverse(ep, returnStack, entryPointStack)
          Add( strip, stripList)
        End if
      End while
      Return stripList
    End function
    Function Traverse (Node entry, InputOutput Stack returnStack,
    InputOutput Stack entryPointStack )
      List Strip = <empty> // output strip (list of instructions)
      Node bb = entry, firstBB, secondBB
      While bb is not <empty> do
        // add basic block to strip
        Foreach Instruction instr in BasicBlock(bb) do
          Add(instr, Strip)
        End foreach
        Mark bb as traversed
        // sechedule BBs at edges of bb
        Bool firstIsCall = (Edge(bb, First) is a call)
        firstBB = RetrieveNode(Edge(bb, First), returnStack)
        If firstBB is not <empty> then
          secondBB = RerieveNode(Edge(bb, Second), returnStack)
        Else
          firstBB = RetrieveNode(Edge(bb, Second), returnStack)
          secondBB = <empty>
        End if
        If firstBB is not <empty> then
          if secondBB is not <empty> then
            // schedule second node. If this is a call edge, push
          called function's entry point node on return stack
            // else push node on entry point stack
            Stack stack = firstIsCall? returnStack: entryPointStack;
            Push(secondBB, stack)
          End if
        End if
        bb = firstBB
      End while
      // reached a traversed node or end of function
      Return strips
    End function
    Function RetrieveNode(Edge edge, InputOutput Stack returnStack)
      Node retrievedBB = <empty>
      If edge exists and is direct then
        // continue traversing this function
        retrievedBB = Node(edge)
      Else if edge is a return instruction (e.g. ‘blr’ in POWER arch.) then
        // traverse back to caller
        retrievedBB = Pop(returnStack)
      End if
      // do not proceed in this direction if node has been traversed already
      If retievedBB is not <empty> and retriebedBB is not traversed then
        Return retrievedBB
      Else
        Return <empty>
      End if
    End function
  • An example strip follows. In the example, the branch instructions, which are not part of the strips, are commented out.
  •
    Strip 6:
    #13b2b29c ...
    # 41 86 00 48 beq- cr1,13b2b2e4 <.pevm_EXECC+0x504>
    #13b2b2e4 ...
    e8 7d 00 08 ld r3,8(r29)
    28 9b 05 7b cmplwi cr1,r27,1403
    e8 63 00 c8 ld r3,200(r3)
    80 03 00 9c lwz r0,156(r3)
    70 00 00 40 andi. r0,r0,64
    # 41 82 00 14 beq- 13b2b30c <.pevm_EXECC+0x52c>
    #13b2b30c ...
    a0 1c 00 34 lhz r0,52(r28)
    70 03 00 40 andi. r3,r0,64
    # 40 82 00 34 bne- 13b2b348 <.pevm_EXECC+0x568>
    80 bc 00 50 lwz r5,80(r28)
    e8 dc 00 56 lwa r6,84(r28)
    e8 7d 00 08 ld r3,8(r29)
    e8 9d 00 88 ld r4,136(r29)
    39 20 00 00 li r9,0
    e8 63 00 00 ld r3,0(r3)
    38 e0 00 00 li r7,0
    39 00 00 00 li r8,0
    e8 84 00 00 ld r4,0(r4)
    # 4b 9f ed 45 bl 1352a080 <.kgicls>
    60 00 00 00 nop
    a0 1c 00 34 lhz r0,52(r28)
    54 00 04 3c rlwinm r0,r0,0,16,30
    80 7c 00 58 lwz r3,88(r28)
    2c 23 00 00 cmpdi r3,0
    b0 1c 00 34 sth r0,52(r28)
    # 41 82 00 0c beq- 13b2b364 <.pevm_EXECC+0x584>
    #13b2b364 ...
    7f a3 eb 78 mr r3,r29
    7f 64 db 78 mr r4,r27
    # 4b fe 8b b5 bl 13b13f20 <.pevm_handle_external_error>
    60 00 00 00 nop
    # 48 00 01 34 b 13b2b4a8 <.pevm_EXECC+0x6c8>
    Strip 7:
    #13b2b35c ...
    e8 7d 00 b0 ld r3,176(r29)
    93 c3 00 98 stw r30,152(r3)
    Strip 8:
    #13b2b2fc ...
    # 40 86 00 10 bne- cr1,13b2b30c <.pevm_EXECC+0x52c>
    7f a3 eb 78 mr r3,r29
    # 4b fe 9e 9d bl 13b151a0 <.pfrfoe_flush_oci_error>
    60 00 00 00 nop
  • At 108, the generated strips of two implementations of a function are compared. The comparison can be a textual or character-by-character comparison. Incorrect transformations are identified from the comparison. For example, the strip or strips corresponding to the transformed or optimized code that do not match the strip or strips of the original code are identified as being incorrect.
  • The system and method of the present disclosure may be implemented and run on a general-purpose computer or computer system. The computer system may be any type of known or will be known systems and may typically include a processor, memory device, a storage device, input/output devices, internal buses, and/or a communications interface for communicating with other computer systems in conjunction with communication hardware and software, etc.
  • The terms “computer system” and “computer network” as may be used in the present application may include a variety of combinations of fixed and/or portable computer hardware, software, peripherals, and storage devices. The computer system may include a plurality of individual components that are networked or otherwise linked to perform collaboratively, or may include one or more stand-alone components. The hardware and software components of the computer system of the present application may include and may be included within fixed and portable devices such as desktop, laptop, and server. A module may be a component of a device, software, program, or system that implements some “functionality”, which can be embodied as software, hardware, firmware, electronic circuitry, or etc.
  • The embodiments described above are illustrative examples and it should not be construed that the present invention is limited to these particular embodiments. Thus, various changes and modifications may be effected by one skilled in the art without departing from the spirit or scope of the invention as defined in the appended claims.

Claims (1)

1. A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform a method for validating binary code transformations, comprising:
analyzing binary code of an executable program to produce a sequence of basic units comprising smallest elements of the executable program that stay intact under every reordering;
generating control flow graph associated with the sequence of basic units;
generating invariant linear fiction representation based on the control flow graph;
analyzing optimized transformation of the executable program to produce a second sequence of basic units;
generating second control flow graph associated with the second sequence of basic units;
generating second invariant linear function representation based on the second control flow graph;
comparing the invariant linear function representation and the second invariant linear function representation; and
identifying one or more incorrect transformations in the optimized transformation,
wherein the invariant linear function representation and the second invariant linear function representation are invariants under a set of predefined optimization transformation and include a sequence of strips comprising a path through a trace of non-branch instructions executing sequentially when the executable program runs.
US12/206,578 2007-11-15 2008-09-08 Method for validation of binary code transformations Abandoned US20090133005A1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US12/206,578 US20090133005A1 (en) 2007-11-15 2008-09-08 Method for validation of binary code transformations

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US11/940,750 US7430733B1 (en) 2007-11-15 2007-11-15 Method for validation of binary code transformations
US12/206,578 US20090133005A1 (en) 2007-11-15 2008-09-08 Method for validation of binary code transformations

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US11/940,750 Continuation US7430733B1 (en) 2007-11-15 2007-11-15 Method for validation of binary code transformations

Publications (1)

Publication Number Publication Date
US20090133005A1 true US20090133005A1 (en) 2009-05-21

Family

ID=39776574

Family Applications (2)

Application Number Title Priority Date Filing Date
US11/940,750 Expired - Fee Related US7430733B1 (en) 2007-11-15 2007-11-15 Method for validation of binary code transformations
US12/206,578 Abandoned US20090133005A1 (en) 2007-11-15 2008-09-08 Method for validation of binary code transformations

Family Applications Before (1)

Application Number Title Priority Date Filing Date
US11/940,750 Expired - Fee Related US7430733B1 (en) 2007-11-15 2007-11-15 Method for validation of binary code transformations

Country Status (1)

Country Link
US (2) US7430733B1 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150143342A1 (en) * 2013-11-15 2015-05-21 Microsoft Corporation Functional validation of software

Families Citing this family (14)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8429623B2 (en) * 2007-01-16 2013-04-23 Oracle America Inc. Processing engine for enabling a set of code intended for a first platform to be executed on a second platform
US8954546B2 (en) 2013-01-25 2015-02-10 Concurix Corporation Tracing with a workload distributor
US20130283281A1 (en) 2013-02-12 2013-10-24 Concurix Corporation Deploying Trace Objectives using Cost Analyses
US8997063B2 (en) 2013-02-12 2015-03-31 Concurix Corporation Periodicity optimization in an automated tracing system
US8924941B2 (en) 2013-02-12 2014-12-30 Concurix Corporation Optimization analysis using similar frequencies
US20130227529A1 (en) * 2013-03-15 2013-08-29 Concurix Corporation Runtime Memory Settings Derived from Trace Data
US9575874B2 (en) 2013-04-20 2017-02-21 Microsoft Technology Licensing, Llc Error list and bug report analysis for configuring an application tracer
US9292415B2 (en) 2013-09-04 2016-03-22 Microsoft Technology Licensing, Llc Module specific tracing in a shared module environment
EP3069241B1 (en) 2013-11-13 2018-08-15 Microsoft Technology Licensing, LLC Application execution path tracing with configurable origin definition
US10037366B2 (en) 2014-02-07 2018-07-31 Microsoft Technology Licensing, Llc End to end validation of data transformation accuracy
US11307962B2 (en) * 2018-07-09 2022-04-19 United States Of America As Represented By The Secretary Of The Navy Method for semantic preserving transform mutation discovery and vetting
US11844738B2 (en) 2018-08-17 2023-12-19 Troy Bruesewitz Therapy device for neck and spine
US11074167B2 (en) * 2019-03-25 2021-07-27 Aurora Labs Ltd. Visualization of code execution through line-of-code behavior and relation models
CN114461198A (en) * 2021-12-27 2022-05-10 上海交通大学四川研究院 Program generation method, device, equipment and medium based on visual low code

Citations (27)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5371747A (en) * 1992-06-05 1994-12-06 Convex Computer Corporation Debugger program which includes correlation of computer program source code with optimized object code
US5450575A (en) * 1991-03-07 1995-09-12 Digital Equipment Corporation Use of stack depth to identify machine code mistakes
US5758051A (en) * 1996-07-30 1998-05-26 International Business Machines Corporation Method and apparatus for reordering memory operations in a processor
US5790867A (en) * 1996-01-02 1998-08-04 International Business Machines Corporation Compiler with extended redundant copy elimination
US5802373A (en) * 1996-01-29 1998-09-01 Digital Equipment Corporation Method for providing a pipeline interpreter for a variable length instruction set
US5889999A (en) * 1996-05-15 1999-03-30 Motorola, Inc. Method and apparatus for sequencing computer instruction execution in a data processing system
US5966541A (en) * 1997-12-04 1999-10-12 Incert Software Corporation Test protection, and repair through binary-code augmentation
US5966539A (en) * 1994-03-01 1999-10-12 Digital Equipment Corporation Link time optimization with translation to intermediate program and following optimization techniques including program analysis code motion live variable set generation order analysis, dead code elimination and load invariant analysis
US6035123A (en) * 1995-11-08 2000-03-07 Digital Equipment Corporation Determining hardware complexity of software operations
US6075942A (en) * 1998-05-04 2000-06-13 Sun Microsystems, Inc. Encoding machine-specific optimization in generic byte code by using local variables as pseudo-registers
US6226789B1 (en) * 1996-01-29 2001-05-01 Compaq Computer Corporation Method and apparatus for data flow analysis
US6275981B1 (en) * 1998-11-12 2001-08-14 Hewlett-Packard Company Method and system for correlating profile data dynamically generated from an optimized executable program with source code statements
US6289505B1 (en) * 1997-11-18 2001-09-11 Sun Microsystems, Inc. Method, apparatus and computer programmed product for binary re-optimization using a high level language compiler
US6292938B1 (en) * 1998-12-02 2001-09-18 International Business Machines Corporation Retargeting optimized code by matching tree patterns in directed acyclic graphs
US6530079B1 (en) * 1999-06-02 2003-03-04 International Business Machines Corporation Method for optimizing locks in computer programs
US6598221B1 (en) * 2000-04-13 2003-07-22 Koninklijke Philips Electronics N.V. Assembly code performance evaluation apparatus and method
US20040098710A1 (en) * 2002-11-14 2004-05-20 Jim Radigan Systems and methods to read, optimize, and verify byte codes for a multiplatform jit
US6748584B1 (en) * 1999-12-29 2004-06-08 Veritas Operating Corporation Method for determining the degree to which changed code has been exercised
US20040128659A1 (en) * 2002-12-31 2004-07-01 Intel Corporation Run-time behavior preserving partial redundancy elimination
US6829733B2 (en) * 2001-05-07 2004-12-07 National Instruments Corporation System and method for graphically detecting differences between test executive sequence files
US20050257202A1 (en) * 2004-05-14 2005-11-17 Daniel Kaestner Data-flow based post pass optimization in dynamic compilers
US20050268293A1 (en) * 2004-05-25 2005-12-01 International Business Machines Corporation Compiler optimization
US20060080645A1 (en) * 2000-01-14 2006-04-13 Miguel Miranda System and method for optimizing source code
US20060130016A1 (en) * 2003-03-17 2006-06-15 Wagner John R Method of kernal-mode instruction interception and apparatus therefor
US20060282807A1 (en) * 2005-06-03 2006-12-14 Nec Laboratories America, Inc. Software verification
US7185328B2 (en) * 2002-05-30 2007-02-27 Microsoft Corporation System and method for improving a working set
US7207038B2 (en) * 2003-08-29 2007-04-17 Nokia Corporation Constructing control flows graphs of binary executable programs at post-link time

Patent Citations (27)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5450575A (en) * 1991-03-07 1995-09-12 Digital Equipment Corporation Use of stack depth to identify machine code mistakes
US5371747A (en) * 1992-06-05 1994-12-06 Convex Computer Corporation Debugger program which includes correlation of computer program source code with optimized object code
US5966539A (en) * 1994-03-01 1999-10-12 Digital Equipment Corporation Link time optimization with translation to intermediate program and following optimization techniques including program analysis code motion live variable set generation order analysis, dead code elimination and load invariant analysis
US6035123A (en) * 1995-11-08 2000-03-07 Digital Equipment Corporation Determining hardware complexity of software operations
US5790867A (en) * 1996-01-02 1998-08-04 International Business Machines Corporation Compiler with extended redundant copy elimination
US6226789B1 (en) * 1996-01-29 2001-05-01 Compaq Computer Corporation Method and apparatus for data flow analysis
US5802373A (en) * 1996-01-29 1998-09-01 Digital Equipment Corporation Method for providing a pipeline interpreter for a variable length instruction set
US5889999A (en) * 1996-05-15 1999-03-30 Motorola, Inc. Method and apparatus for sequencing computer instruction execution in a data processing system
US5758051A (en) * 1996-07-30 1998-05-26 International Business Machines Corporation Method and apparatus for reordering memory operations in a processor
US6289505B1 (en) * 1997-11-18 2001-09-11 Sun Microsystems, Inc. Method, apparatus and computer programmed product for binary re-optimization using a high level language compiler
US5966541A (en) * 1997-12-04 1999-10-12 Incert Software Corporation Test protection, and repair through binary-code augmentation
US6075942A (en) * 1998-05-04 2000-06-13 Sun Microsystems, Inc. Encoding machine-specific optimization in generic byte code by using local variables as pseudo-registers
US6275981B1 (en) * 1998-11-12 2001-08-14 Hewlett-Packard Company Method and system for correlating profile data dynamically generated from an optimized executable program with source code statements
US6292938B1 (en) * 1998-12-02 2001-09-18 International Business Machines Corporation Retargeting optimized code by matching tree patterns in directed acyclic graphs
US6530079B1 (en) * 1999-06-02 2003-03-04 International Business Machines Corporation Method for optimizing locks in computer programs
US6748584B1 (en) * 1999-12-29 2004-06-08 Veritas Operating Corporation Method for determining the degree to which changed code has been exercised
US20060080645A1 (en) * 2000-01-14 2006-04-13 Miguel Miranda System and method for optimizing source code
US6598221B1 (en) * 2000-04-13 2003-07-22 Koninklijke Philips Electronics N.V. Assembly code performance evaluation apparatus and method
US6829733B2 (en) * 2001-05-07 2004-12-07 National Instruments Corporation System and method for graphically detecting differences between test executive sequence files
US7185328B2 (en) * 2002-05-30 2007-02-27 Microsoft Corporation System and method for improving a working set
US20040098710A1 (en) * 2002-11-14 2004-05-20 Jim Radigan Systems and methods to read, optimize, and verify byte codes for a multiplatform jit
US20040128659A1 (en) * 2002-12-31 2004-07-01 Intel Corporation Run-time behavior preserving partial redundancy elimination
US20060130016A1 (en) * 2003-03-17 2006-06-15 Wagner John R Method of kernal-mode instruction interception and apparatus therefor
US7207038B2 (en) * 2003-08-29 2007-04-17 Nokia Corporation Constructing control flows graphs of binary executable programs at post-link time
US20050257202A1 (en) * 2004-05-14 2005-11-17 Daniel Kaestner Data-flow based post pass optimization in dynamic compilers
US20050268293A1 (en) * 2004-05-25 2005-12-01 International Business Machines Corporation Compiler optimization
US20060282807A1 (en) * 2005-06-03 2006-12-14 Nec Laboratories America, Inc. Software verification

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150143342A1 (en) * 2013-11-15 2015-05-21 Microsoft Corporation Functional validation of software

Also Published As

Publication number Publication date
US7430733B1 (en) 2008-09-30

Similar Documents

Publication Publication Date Title
US7430733B1 (en) Method for validation of binary code transformations
US9032379B2 (en) Platform specific optimizations in static compilers
Kong et al. When polyhedral transformations meet SIMD code generation
Pop et al. GRAPHITE: Polyhedral analyses and optimizations for GCC
Zhang et al. Using hammock graphs to structure programs
Porpodas et al. Throttling automatic vectorization: When less is more
US8387026B1 (en) Compile-time feedback-directed optimizations using estimated edge profiles from hardware-event sampling
CN110825386B (en) Code compiling method and device and storage medium
US8191057B2 (en) Systems, methods, and computer products for compiler support for aggressive safe load speculation
US20060048122A1 (en) Method, system and computer program product for hierarchical loop optimization of machine executable code
US8037464B2 (en) Generating optimized SIMD code in the presence of data dependences
Ebner et al. Generalized instruction selection using SSA-graphs
Shashidhar et al. Functional equivalence checking for verification of algebraic transformations on array-intensive source code
US9201636B2 (en) Method for divergence analysis of pointer-based program
CN104951290A (en) Method and equipment for optimizing software
Sharma et al. Sound bit-precise numerical domains
Soares et al. Side-channel elimination via partial control-flow linearization
Bertholon et al. Jshadobf: A javascript obfuscator based on multi-objective optimization algorithms
Goss Machine code optimization-improving executable object code
Dragan et al. LINGVA: Generating and proving program properties using symbol elimination
US20140344795A1 (en) Computer-readable recording medium, compiling method, and information processing apparatus
Atre et al. Dissecting sequential programs for parallelization—An approach based on computational units
Chouksey et al. Translation validation of loop invariant code optimizations involving false computations
Porpodas et al. PostSLP: cross-region vectorization of fully or partially vectorized code
Brandner et al. Criticality: static profiling for real-time programs

Legal Events

Date Code Title Description
STCB Information on status: application discontinuation

Free format text: ABANDONED -- FAILURE TO PAY ISSUE FEE