WO2019047142A1

WO2019047142A1 - Method for program patching, device, micro control unit, and terminal device

Info

Publication number: WO2019047142A1
Application number: PCT/CN2017/100987
Authority: WO
Inventors: 杨柯; 周永林; 邹景华
Original assignee: 深圳市汇顶科技股份有限公司
Priority date: 2017-09-08
Filing date: 2017-09-08
Publication date: 2019-03-14
Also published as: CN110192178A; CN110192178B

Abstract

A method for program patching, a device, a micro control unit, and a terminal device. The method comprises: when executing a program in a MASK ROM, determining, on the basis of a first correlation, whether a current function in the program needs to be patched, the first correlation being a correlation between a first identifier and the starting address of a patch function corresponding to the current function in an extended read-only memory, and the first identifier being used for identifying the current function (310); and insofar as the current function needs to be patched, executing the first patch function on the basis of the starting address, the first patch function being a patch function corresponding to the current function (320). The method increases the flexibility of the program and increases user experience.

Description

Program patching method, device, micro control unit and terminal device

Technical field

Embodiments of the present invention relate to the field of computers, and, more particularly, to a method, an apparatus, a micro control unit, and a terminal device for patching a program.

Background technique

Read-only memory can be roughly divided into Mask Read Only Memory (MASK ROM), One Time Programable Read Only Memory (OTP ROM), and multiple-time read-only memory (Multi Time). Programable Read Only Memory (MTP ROM) and Erasable Programmable Read Only Memory (FLASH ROM). Among them, MASK ROM has low manufacturing cost, the program has been solidified in the chip generation stage, and cannot be modified after shipment. Therefore, for the sake of cost and power consumption, in the case that the program has been repeatedly modified and tested to be very stable, it can be considered to write the program into the MASK ROM during the chip production process, and then, once the program is written In the MASK ROM, no modifications can be made afterwards, resulting in insufficient flexibility of the program and low user experience.

Summary of the invention

The embodiment of the invention provides a method, a device, a micro control unit and a terminal device for program patching, which can improve the flexibility of the program and improve the user experience.

In a first aspect, a method of program patching is provided, the program being stored in a mask read-only memory MASK ROM, the method comprising:

Determining, according to the first correspondence, whether the current function in the program needs to be patched, when the program in the MASK ROM is executed, where the first correspondence is a patch function corresponding to the current function Corresponding relationship between the start addresses in the extended read-only memory, the first identifier is used to identify the current function; and in the case that the current function needs to be patched, according to the start address, the first a patch function, the first patch function being a patch function corresponding to the current function.

In the embodiment of the present invention, the patch function is stored in the extended read-only memory, and when the current function in the MASK ROM is patched, the first patch function storage address corresponding to the current function is determined by the first correspondence relationship, and The first patch function is run to improve the spirit of the program. Activity, improve user experience.

With reference to the first aspect, in a first implementation manner of the first aspect, when the program in the MASK ROM is executed, determining whether the current function in the program needs to be patched according to the first correspondence, includes: Determining, according to the first correspondence, whether a starting address of the patch function corresponding to the current function is located in an address space of the extended read-only memory; a starting address of the patch function corresponding to the current function is located in the In the case of expanding the address space of the read only memory, it is determined that the current function needs to be patched.

In the embodiment of the present invention, since the patch function is stored in the extended read-only memory, it is easy to determine whether the current function needs to be played by determining whether the start address of the patch function corresponding to the current function is located in the extended read-only memory. patch.

With reference to the first aspect, or the first implementation manner of the first aspect, in a second implementation manner of the first aspect, the performing, according to the starting address, in the case that the current function needs to be patched a first patch function, comprising: a parameter of the current function as a parameter of the first patch function; a starting address in the extended read-only memory according to the first patch function and the first patch function The parameter executes the first patch function.

With reference to the first aspect, or any one of the first and second implementation manners of the first aspect, in a third implementation manner of the first aspect, the extended read only memory is further configured to store a patch function structure The patch function structure includes a parameter variable, a return value variable, and an array of function pointers, the parameter variable is used to pass parameters of the current function, and the return value variable is used to pass after executing any one of the patch functions. Return value, each function pointer in the function pointer array is used to indicate a starting address of each patch function in the extended read-only memory, and the patch function structure is located at the lowest address in the extended read-only memory Within the space.

With reference to the first aspect, or any one of the first to third implementation manners of the first aspect, in a fourth implementation manner of the first aspect, the parameter of the current function is used as the first patch The parameter of the function includes: assigning a parameter of the current function to the parameter variable in the patch function structure; acquiring a parameter of the current function from the parameter variable in the patch function structure as The parameters of the first patch function.

With reference to the first aspect, or any one of the first to fourth implementation manners of the first aspect, in a fifth implementation manner of the first aspect, the method further includes: determining whether the current function is required Returning a value; if the current function requires a return value, assigning a return value obtained by executing the first patch function to the return value variable in the patch function structure; from the patch The return value is obtained from the return value variable in the function structure as a return value of the current function.

With reference to the first aspect, or any one of the first to fifth implementation manners of the first aspect, in a sixth implementation manner of the first aspect, the method further includes: before executing the program, An instance of the patch function structure is copied into the random access memory RAM.

With reference to the first aspect, or any one of the first to sixth implementation manners of the first aspect, in the seventh implementation manner of the first aspect, the extended read only memory includes a one-time burning read-only memory At least one of an OTP ROM, a multiple-shot read-only memory MTP ROM, and an erasable programmable read-only memory FLASH ROM.

In a second aspect, an apparatus for patching a program is provided, comprising one or more components for performing the method embodiments of the first aspect.

In a third aspect, a micro control unit is provided, comprising any of the optional program patching devices of the second aspect or the second aspect.

In a fourth aspect, a terminal device is provided, comprising any of the optional program patching devices of the second aspect or the second aspect.

In a fifth aspect, a computer readable medium is provided for storing program code executed by a device for data analysis, the program code comprising each of the first aspect and the first aspect described above The instructions of the method in the implementation.

According to a sixth aspect, a system chip is provided, the system chip includes an input/output interface, at least one processor, at least one memory, and a bus, the at least one memory is configured to store code, and the at least one processor is configured to invoke the at least one memory Code to perform the operations of the methods of the various aspects above.

DRAWINGS

1 is a system frame diagram of a micro control unit in accordance with an embodiment of the present invention.

2 is a diagram showing a mapping relationship of a memory address space in an embodiment of the present invention.

FIG. 3 is a schematic flowchart of a method for patching a program according to an embodiment of the present invention.

FIG. 4 is another schematic flowchart of a method for patching a program according to an embodiment of the present invention.

FIG. 5 is a schematic block diagram of an apparatus for patching a program according to an embodiment of the present invention.

FIG. 6 is a schematic block diagram of an apparatus for patching a program according to an embodiment of the present invention.

Detailed ways

The technical solutions of the embodiments of the present invention will be described below with reference to the accompanying drawings.

In the embodiment of the present invention, the program stored in the Mask Read Only Memory (MASK ROM) in the Microcontroller Unit (MCU) needs to be patched as an example to perform the method of patching the program in the embodiment of the present invention. It should be noted that the embodiments of the present invention are not limited thereto.

Figure 1 shows the MCU system framework. The MASK ROM stores the firmware. After the central processing unit (CPU) is powered on, the program starts running from the start address of the MASK ROM. One Time Programable Read Only Memory (OTP ROM), Multi Time Programable Read Only Memory (MTP ROM), and Erasable Programmable Read Only Memory (FLASH ROM) are Optional read-only memory, in the actual system, one or more optional read-only memories can be selected according to the application scenario, cost and architecture design of the MCU, and a random access memory (RAM) is used for random access memory (RAM). Store variables, program data, etc. during program execution.

Based on the system framework of the MCU described above, in the embodiment of the present invention, the patch function is stored in the extended read-only memory (OTP ROM, MTP ROM, FLASH ROM), and after determining that the current function needs to be patched, according to the corresponding patch. The function expands the address in the read-only memory and executes the patch function, thereby patching the functions in the MASK ROM, improving the flexibility of the program and improving the user experience.

It is assumed that the processor used in the embodiment of the present invention is a 16-bit processor, and the address space of the memory is 0x0000-0xFFFF. The mapping relationship of a memory address space is as shown in FIG. 2, where 0x0000-0x4000 is a register and random. Accessing the address space of the memory, 0x4000-0x8000 is the storage space of the extended memory, and 0x8000-0xFFFF is the storage space of the MASK ROM. As shown in FIG. 2, the embodiment of the present invention stores the patch function corresponding to the program in the MASK ROM in the extension. Within the address space 0x4000-0x8000 of the read-only memory, the patch function structure is stored in the lowest address space in the extended read-only memory.

FIG. 3 is a schematic flowchart of a method 300 for program patching according to an embodiment of the present invention. As shown in FIG. 3, the method 300 includes some or all of the following steps.

310. Determine, according to the first correspondence relationship, whether the current function in the program needs to be patched according to the first correspondence relationship when the program in the MASK ROM is executed, where the first correspondence relationship is a complement corresponding to the current identifier and the current function. The correspondence between the starting addresses of the functions in the extended read-only memory, the first identifier being used to identify the current function.

320. In the case that the current function needs to be patched, according to the starting address, the first patch function is executed, and the first patch function is a patch function corresponding to the current function.

In the embodiment of the present invention, according to the address of the first patch function in the extended read-only memory, the first patch function is invoked to patch the current function, thereby improving the flexibility of the program and improving the user experience.

Optionally, the current function in the embodiment of the present invention is stored in the MASK ROM, that is, the current function in the embodiment of the present invention is one or more functions in the program stored in the MASK ROM.

Optionally, the patch function corresponding to the current function is stored in the extended read-only memory.

Optionally, the extended read only memory may include at least one of an OTP ROM, an MTP ROM, and a FLASH ROM.

It should be understood that the first identifier is a flag that the user may need to patch the function in the program in the MASK ROM according to a preset rule, and the first identifier may have multiple. For example, the user numbers the commonly used key functions or commonly used important functions in the program stored in the MASK ROM, and any number in the number can be used as the first identifier, and the key function or the important function can be the user according to different evaluation rules. definite.

Optionally, the first correspondence relationship is a correspondence between the first identifier and a start function of the patch function corresponding to the current function in the extended read-only memory.

It should be understood that the current function may be any one of the programs stored in the MASK ROM, and the first identifier is used to identify that the current function can be understood as being used to identify the current function when the current function is any function in the MASK ROM. The identifier of the function is the first identifier. For example, there are 5 functions in the program stored in the MASK ROM. The third function has a number. When the program runs to the third function, the third function is used as the current function. Function, the number of the third function can be regarded as the first identifier.

Optionally, the current function in the embodiment of the present invention may be understood as a function to be patched, and whether the function to be patched needs to be patched needs to be determined according to the first correspondence.

That is to say, there may be multiple functions to be patched in the MASK ROM program. When determining that a function needs to be patched, the corresponding identifier of the function can be used as the first identifier.

For example, there are 10 functions in the program stored in the MASK ROM, and the second function, the third function, the fifth function, the seventh function, and the tenth function respectively correspond to numbers 1, 2, and 2. 3, 4, 5, in this case, when the program runs to the second function, the second function can be used as the current function, and the number 1 of the corresponding second function is used as the first identifier to determine the second Whether the function needs to be patched; when the program runs to the fifth function, the fifth function can be used as the current function, and the number 5 of the corresponding fifth function is used as the first identifier to determine whether the fifth function needs to be patched. , and so on, when the program runs to which numbered function, the numbered function can be used as the current function, and the number is used as the first identifier.

Optionally, when the current function needs to be patched, according to the starting address, the first patch function corresponding to the current function may be determined, and after obtaining the parameter of the first patch function, the first patch function is executed.

Optionally, after determining that the current function needs to be patched, the parameter of the current function may be obtained, and the parameter of the current function is used as a parameter of the first patch function, and when the first patch function is run to patch the current function, The parameters of the current function are the parameters of the first patch function.

Specifically, the embodiment of the present invention provides a patch function structure, and the patch function structure may be stored in a lowest address space of the extended read-only memory, where the patch function structure includes a parameter variable, a return value variable, and an array of function pointers, where The parameter variable is used to pass at least one parameter of the current function in the current function. The return value variable is used to pass the return value obtained after executing any patch function. Each function pointer in the function pointer array is used to indicate each patch function. The starting address in the extended read-only memory.

The program described below is a patch function structure.

As can be seen from the above program, this patch function structure defines 64 patch functions, where parameter[] is a parameter variable, ret_val[] is a return value variable, func_patch_addr[] is an array of function pointers, and the function structure In the body, the func_patch_addr[] function pointer array includes 64 Function pointers, each function pointer indicating the starting address of a patch function.

Since the function pointer can be used to indicate the start address of the patch function, the first correspondence relationship can be understood as a correspondence between the first identifier and the first function pointer, and the first function pointer is used to indicate the start of the patch function corresponding to the current function. address.

Optionally, the first correspondence may be stored in a patch function structure.

After the patch function structure is defined, the parameter of the current function can be assigned to the parameter variable parameter[] in the patch function structure. When the first patch function is run, the current function can be extracted from the parameter variable parameter[]. The parameters are used as parameters of the first patch function.

After the first patch function obtains the parameter of the current function as the parameter of the first patch function, the first patch function is executed, and when the first patch function is finished, whether the current function needs a return value determines whether the first function will be run. The return value after the patch function is assigned to the return value variable ret_val[] in the patch function structure, that is, in the case that the current D function needs a return value, after running the first patch function, the first patch function will be executed. The return value is assigned to the return value variable ret_val[] in the patch function structure.

It should be understood that the patch function structure has one and only one, that is, there is only one patch function structure regardless of the number of patch functions, and the function pointer array in the patch function structure includes the addresses of all current patch functions, parameters. The variable parameter[] and the return value variable ret_val[] are empty at the initial stage. When a function is patched, the parameter of the function is assigned to the parameter variable parameter[], and after running the patch function corresponding to the function, it will run. The obtained value is assigned to the return value variable ret_val[]. The next time the other function is patched, the value in the parameter variable parameter[] is the parameter of the function to be patched, and the return value variable ret_val[] The value is the return value obtained by running the patch function corresponding to the function that needs to be patched. Therefore, the parameter variable parameter[] and the return value variable ret_val[] in the patch function structure vary with the current function. However, the function pointer array func_patch_addr[] remains unchanged.

Since the parameter variable parameter[] and the return value variable ret_val[] in the patch function structure change with the running of the program, in the initialization phase, an instance of the patch function structure needs to be copied into the RAM, and subsequently All operations of the patch function structure run in RAM.

FIG. 4 is a schematic flowchart of a method 400 for patching a program according to an embodiment of the present invention. As shown in FIG. 4, the method 400 includes some or all of the following steps.

405. Determine, according to the first identifier and the first correspondence, whether an address indicated by the first function pointer corresponding to the first identifier is an empty address, and the address indicated by the first function pointer is empty. Then, in step 410, if the address indicated by the first function pointer is not empty, step 415 is performed.

Optionally, the first identifier is used to identify the current function.

Optionally, the first function pointer is used to indicate a starting address of the patch function corresponding to the current function.

Optionally, the first correspondence is a correspondence between the first identifier and a starting address of the patch function corresponding to the current function in the extended read-only memory, that is, a correspondence between the first identifier and the first function pointer.

Optionally, the first correspondence is stored in an array of pointer functions of the patch function structure.

Optionally, the patch function corresponding to the current function is also stored in the extended read-only memory.

410, continue to execute the function after the current function in the MASK ROM.

415, according to whether the address indicated by the first function pointer is located in the storage space of the extended read-only memory, determining whether the current function needs to be patched, and performing the step in the storage space indicated by the first function pointer is not located in the extended read-only memory. 420. When the current function needs to be patched, step 425 is performed.

Optionally, since the patch function is stored in the extended read-only memory in the embodiment of the present invention, it is determined whether the address indicated by the first function pointer is located in the extended read-only memory, and whether the current function needs to be patched may be determined.

420, an error message is returned, and the program operation ends.

It should be understood that since the patch function is stored in the extended read-only memory, when the address indicated by the first function pointer is not located in the storage space of the extended read-only memory, indicating that the current function does not have a corresponding patch function, the current function cannot be performed on the current function. After patching, the program runs.

425. Assign the parameter of the current function to the parameter variable parameter[] in the patch function structure.

430. The program jumps to the first patch function corresponding to the current function, and executes the first patch function.

435. Extract the parameter as a parameter of the first patch function from the parameter variable parameter[] in the patch function structure.

It should be understood that, at this time, the parameter of the first patch function parameter variable parameter[] is the parameter of the current function, that is, the parameter of the current function is assigned to the patch parameter variable parameter[] in the patch function structure in step 425.

440. After the execution of the first patch function ends, according to whether the current function needs a return value, determine whether to assign the return value to the return value variable ret_val[] in the patch function structure, in the current function. When the number needs to return a value, step 445 is executed, and when the current function does not need to return a value, step 450 is performed.

445, when the current function needs to return a value, assign the return value to the return value variable ret_val[].

Optionally, after assigning the return value to the return value variable ret_val[], the first patch function ends, continues to execute the function after the current function, and continues to determine whether the function after the current function needs to be patched, after the current function. Method 400 is repeated when there is a function that needs to be patched in the function.

450. When the current function does not need a return value, the first patch function ends and continues to execute the function after the current function.

The embodiment of the method of the present invention is described in detail with reference to FIG. 3 and FIG. 4, and the device embodiment of the embodiment of the present invention will be described in detail below with reference to FIG. 5 and FIG. 6. It should be understood that the device embodiment and the method embodiment are described. Corresponding to each other, a similar description can be referred to the method embodiment.

FIG. 5 is a schematic block diagram of a program patching apparatus 500 according to an embodiment of the present invention. As shown in FIG. 5, the apparatus 500 includes some or all of the following component blocks.

A mask read only memory (MASK ROM) 510 is used to store the program.

The extended read only memory 520 is configured to store a corresponding patch function in the program.

The processor 530 is configured to determine, according to the first correspondence, whether the current function in the program needs to be patched when the program in the MASK ROM is executed, where the first correspondence is that the first identifier and the patch function corresponding to the current function are in the extended read-only manner. The correspondence between the starting addresses in the memory, the first identifier is used to identify the current function.

The processor 530 is further configured to: when the current function needs to be patched, execute the first patch function according to the starting address, where the first patch function is a patch function corresponding to the current function.

It should be understood that the current function can be a function or multiple functions.

Optionally, the extended read only memory 520 can be at least one of an OTP ROM, an MTP ROM, and a FLASH ROM.

It should be understood that the first identifier is a flag that the user may need to patch the function in the program in the MASK ROM according to a preset rule, and the first identifier may have multiple. For example, the user numbers the commonly used key functions or commonly used important functions in the program stored in the MASK ROM, and any one of the numbers can be used as the first identifier, and the key function or the important function can be The user is determined according to different evaluation rules.

Optionally, the processor 530 is further configured to determine, according to the first correspondence, whether a starting address of the first patch function is located in an address space of the extended read-only memory.

Optionally, the processor 530 is further configured to determine that the current function needs to be patched if the start address of the first patch function is located in an address space of the extended read-only memory.

It should be understood that, in the embodiment of the present invention, since the patch function is stored in the extended read-only memory, the current function is a function that needs to be patched, where the start address of the first patch function is located in the extended read-only memory.

Optionally, the processor 530 is further configured to determine, according to the storage address in the extended read-only memory of the first patch function, the first patch function corresponding to the current function.

Optionally, the processor 530 is further configured to execute the first patch function according to the parameter of the first patch function.

Optionally, the processor 530 is further configured to obtain parameters of the current function.

Optionally, the processor 530 is further configured to use a parameter of the current function as a parameter of the first patch function.

Specifically, the embodiment of the present invention provides a patch function structure, and the patch function structure may be stored in a lowest address space of the extended read-only memory, where the patch function structure includes a parameter variable, a return value variable, and an array of function pointers, where The parameter variable is used to pass the parameters of the current function. The return value variable is used to pass the return value obtained after executing any patch function. Each function pointer in the function pointer array is used to indicate that each patch function is in the extended read-only memory. starting address.

Since the function pointer can be used to indicate the start address of the patch function, the first correspondence relationship can be understood as a correspondence between the first identifier and the function pointer, and the function pointer is used to indicate the start address of the patch function corresponding to the current function.

Therefore, the processor 530 can assign the parameter of the current function to the parameter variable in the patch function structure. When the first patch function is run, the parameter of the current function is obtained from the parameter variable in the patch function structure as the first patch function. Parameters.

Optionally, the processor 530 is further configured to determine whether the current function needs a return value.

Optionally, the processor 530 is further configured to: when the current function needs a return value, assign a return value obtained by running the patch function corresponding to the current function to a return value variable in the patch function structure.

Optionally, the processor 530 is further configured to copy an instance of the patch function structure into the random access memory RAM.

It should be understood that the program patching apparatus 500 in the embodiment of the present invention may correspond to the program patching apparatus in the method embodiment, and the above-mentioned and other operations and/or functions of the respective components in the patching apparatus 500 are respectively Corresponding processes in the respective methods in FIG. 3 and FIG. 4 are implemented, and are not described herein again for brevity.

FIG. 6 is a schematic block diagram of an apparatus 600 for program patching in accordance with an embodiment of the present invention. As shown in FIG. 6, the program patched device 600 includes a memory 610 and a processor 620 that communicate with one another via internal connection paths to communicate control and/or data signals.

The memory 610 is configured to store program code;

The processor 620 is configured to invoke the program code to implement the methods in the foregoing embodiments of the embodiments of the present invention.

In the embodiment of the present invention, the processor 620 may be a central processing unit (CPU), a network processor (NP), or a combination of a CPU and an NP. The processor may further include a hardware chip. The hardware chip may be an Application-Specific Integrated Circuit (ASIC), a Programmable Logic Device (PLD), or a combination thereof.

Embodiments of the present invention provide a computer readable medium for storing computer program code, the computer program comprising instructions for performing the method of patching a program of the embodiment of the present invention in FIGS. 3 and 4. The readable medium may be a read-only memory (ROM) or a random access memory (RAM), which is not limited in the embodiment of the present invention.

It should be understood that the program patching apparatus 600 in accordance with an embodiment of the present invention may correspond to the program patching apparatus in the method embodiment, and that the above and other operations and/or functions of the various components in the program patching apparatus 600 are respectively The corresponding processes of the various methods in FIG. 3 and FIG. 4 are implemented, and are not described herein for brevity.

An embodiment of the present invention further provides a system chip, the system chip includes an input and output interface, at least one processor, at least one memory, and a bus, the at least one memory is configured to store an instruction, and the at least one processor is configured to invoke the at least one The instructions of the memory perform the operations of the methods of the various aspects described above.

The embodiment of the present invention further provides an MCU, which includes the device 600 for patching the program described above.

The embodiment of the invention further provides a terminal device, which comprises the device 600 for patching the program described above.

It should be understood that the term "and/or" herein is merely an association describing the associated object, indicating that there may be three relationships, for example, A and/or B, which may indicate that A exists separately, and A and B exist at the same time. There are three cases of B alone. In addition, the character "/" in this article generally indicates that the contextual object is an "or" relationship.

Those of ordinary skill in the art will appreciate that the elements and algorithm steps of the various examples described in connection with the embodiments disclosed herein can be implemented in electronic hardware or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the solution. A person skilled in the art can use different methods to implement the described functions for each particular application, but such implementation should not be considered to be beyond the scope of the embodiments of the invention.

A person skilled in the art can clearly understand that for the convenience and brevity of the description, the specific working process of the system, the device and the unit described above can refer to the corresponding process in the foregoing method embodiment, and details are not described herein again.

In the several embodiments provided by the present application, it should be understood that the disclosed systems, devices, and methods may be implemented in other manners. For example, the device embodiments described above are merely illustrative. For example, the division of the unit is only a logical function division. In actual implementation, there may be another division manner, for example, multiple units or components may be combined or Can be integrated into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection through some interface, device or unit, and may be in an electrical, mechanical or other form.

The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of the embodiment.

In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

In the above embodiments, all or part of the software, hardware, firmware or any of them may be Combined to achieve. When implemented in software, it may be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the processes or functions described in accordance with embodiments of the present invention are generated in whole or in part. The computer can be a general purpose computer, a special purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer readable storage medium or transferred from one computer readable storage medium to another computer readable storage medium, for example, the computer instructions can be from a website site, computer, server or data center Transmission to another website site, computer, server or data center via wired (eg coaxial cable, fiber optic, digital subscriber line DSL) or wireless (eg infrared, wireless, microwave, etc.). The computer readable storage medium can be any available media that can be accessed by a computer or a data storage device such as a server, data center, or the like that includes one or more available media. The usable medium may be a magnetic medium, such as a floppy disk, a hard disk, a magnetic tape, an optical medium such as a DVD, or a semiconductor medium such as a Solid State Disk (SSD).

The foregoing is only a specific embodiment of the embodiments of the present invention, but the scope of protection of the embodiments of the present invention is not limited thereto, and any person skilled in the art can easily use the technical scope disclosed in the embodiments of the present invention. All changes or substitutions are contemplated to be within the scope of the embodiments of the invention. Therefore, the scope of protection of the embodiments of the present invention should be determined by the scope of the claims.

Claims

A method for patching a program, wherein the program is stored in a mask read-only memory MASK ROM, the method comprising:

Determining, according to the first correspondence, whether the current function in the program needs to be patched, when the program in the MASK ROM is executed, where the first correspondence is a patch function corresponding to the current function a correspondence between start addresses in the extended read only memory, the first identifier being used to identify the current function;

In the case that the current function needs to be patched, the first patch function is executed according to the start address, and the first patch function is a patch function corresponding to the current function.
The method according to claim 1, wherein when the program in the MASK ROM is executed, determining whether the current function in the program needs to be patched according to the first correspondence, includes:

Determining, according to the first correspondence, whether a starting address of the patch function corresponding to the current function is located in an address space of the extended read-only memory;

In a case where the start address of the patch function corresponding to the current function is located in the address space of the extended read-only memory, it is determined that the current function needs to be patched.
The method according to claim 1 or 2, wherein in the case that the current function needs to be patched, the first patch function is executed according to the starting address, including:

Taking the parameter of the current function as a parameter of the first patch function;

The first patch function is executed according to a start address of the first patch function in the extended read-only memory and a parameter of the first patch function.
The method according to claim 3, wherein the extended read only memory is further configured to store a patch function structure, wherein the patch function structure includes a parameter variable, a return value variable, and an array of function pointers, the parameter The variable is used to pass a parameter of the current function, and the return value variable is used to pass a return value obtained after executing any one of the patch functions, and each function pointer in the function pointer array is used to indicate that each patch function is expanded. A starting address in a read only memory, the patch function structure being located in a lowest address space in the extended read only memory.
The method according to claim 4, wherein the parameter of the current function is used as a parameter of the first patch function, including:

Assigning a parameter of the current function to the parameter variable in the patch function structure;

Obtaining a parameter of the current function as a parameter of the first patch function from the parameter variable in the patch function structure.
The method according to claim 4 or 5, wherein the method further comprises:

Determining whether the current function requires a return value;

And in a case that the current function needs a return value, assigning a return value obtained by executing the first patch function to the return value variable in the patch function structure;

The return value is obtained from the return value variable in the patch function structure as a return value of the current function.
The method according to any one of claims 4 to 6, wherein the method further comprises:

An instance of the patch function structure is copied into the random access memory RAM prior to execution of the program.
The method according to any one of claims 1 to 7, wherein the extended read only memory comprises a once-read ROM read only memory OTP ROM, a multi-burn ROM memory read-only memory MTP ROM, and an erasable programmable At least one of read-only memory FLASH ROMs.
A program patching device, characterized in that the device comprises:

a mask read only memory MASK ROM for storing the program;

An extended read only memory for storing a corresponding patch function in the program;

a processor, configured to determine, according to the first correspondence, whether the current function in the program needs to be patched when the program in the MASK ROM is executed, where the first correspondence is a first identifier and the current Corresponding relationship between the start function of the patch function corresponding to the function in the extended read-only memory, the first identifier is used to identify the current function;

The processor is further configured to execute a first patch function according to the start address, where the current function needs to be patched, where the first patch function is a patch function corresponding to the current function.
The device according to claim 9, wherein the processor is further configured to determine, according to the first correspondence, whether a starting address of a patch function corresponding to the current function is located in the extended read only memory Within the address space;

The processor is further configured to determine that the current function needs to be patched if a start address of the patch function corresponding to the current function is located in an address space of the extended read-only memory.
The apparatus according to claim 9 or 10, wherein said processor is further Taking the parameter of the current function as a parameter of the first patch function;

The processor is further configured to execute the first patch function according to a start address of the first patch function in the extended read-only memory and a parameter of the first patch function.
The apparatus according to claim 11, wherein the extended read only memory is further configured to store a patch function structure, wherein the patch function structure includes a parameter variable, a return value variable, and an array of function pointers, wherein the parameter The variable is used to pass a parameter of the current function, and the return value variable is used to pass a return value obtained after executing any one of the patch functions, and each function pointer in the function pointer array is used to indicate that each patch function is expanded. A starting address in a read only memory, the patch function structure being located in a lowest address space in the extended read only memory.
The apparatus according to claim 12, wherein the processor is further configured to assign a parameter of the current function to the parameter variable in the patch function structure;

The processor is further configured to obtain, as the parameter of the first patch function, a parameter of the current function from the parameter variable in the patch function structure.
The apparatus according to claim 12 or 13, wherein the processor is further configured to determine whether the current function requires a return value;

The processor is further configured to: when the current function needs a return value, assign a return value obtained by executing the first patch function to the return value variable in the patch function structure;

The processor is further configured to obtain the return value from the return value variable in the patch function structure as a return value of the current function.
The apparatus according to any one of claims 12 to 14, wherein the processor is further configured to copy an instance of the patch function structure into a random access memory RAM.
The apparatus according to any one of claims 9 to 15, wherein the extended read only memory comprises a one-time read-only memory OTP ROM, a multi-program ROM, and an erasable programmable At least one of read-only memory FLASH ROMs.
A micro-control unit MCU, characterized in that the MCU comprises a program patching device according to any one of claims 9 to 16.
A terminal device, characterized in that the terminal device comprises a program patching device according to any one of claims 9 to 16.