Memory writer with deflective memory-cell handling capability

[0002] The present invention relates to a method and system for modifying a microprogram-code before writing it into a partially defective memory.

[0003] In the past, memory chips with defective cells will not be sold in the marketplace. However, with the advent of a number of state-of-art techniques, defective memory chip can behave as a defective-free memory chip. And there are a number of patents addressing methods of using partially defective memories as transparently “good” memories. It is also well known that defective memory-cells can be located by any appropriate testing procedure, such as alternatively writing “1” and “0” in each bit location and then verifying the results.

[0004] U.S. Pat. No. 4,939,694 to Eaton et. al., describes a self-testing and self-repairing memory system. The memory system tests itself during field use to locate defective memory-cells. Once these defective memory-cells are located, the memory system uses the error correction code engine to correct these defective memory-cells. When the error correction code engine becomes overburdened, then the memory system replaces these defective memory-cells.

[0005] U.S. Pat. No. 5,644,541, to Siu et. al., describes a memory system comprising a plurality of semiconductor memories with some bad bits, a substitution memory and a mapping logic to redirect accesses to bad-bit locations in the semiconductor memories to good storage cells within the substitution memory.

[0006] U.S. Pat. No. 5,278,847, to Helbig, Sr. and Anastasia, describes a fault-tolerating memory system that uses an error-detecting-and-correcting (EDAC) code. The reliability of storage is greatly improved by extension of each word to add EDAC encoding and spare-bit portions, as well as by extension of depth to allow spare words to be present, along with high-reliability storage of word maps.

[0007] U.S. Pat. No. 5,579,266 to Tahara, handles defective memory by use of laser repair, or programmable fuse repair, and replaces defective memory-cells with redundant rows and columns.

[0008] Executable machine code are typically generated from the source code of a computer program by the compile and link operations. As the executable machine code is obtained, it is ready to be loaded into memories for program execution.

[0009] It is observed that, the error checking and error correcting techniques, or memory re-direct techniques, provided by some of the prior arts inevitably adds overhead to the hardware design and/or program execution each time the executable machine code is executed. On the other hand, the redundant memories, circuits and the defective memory repair work provided by some prior arts also add design and operation complications.

[0010] FIG. 1 discloses the general concept of the present invention.

[0011] FIG. 2 shows the processes performed by a memory tester according to the invention.

[0012] FIG. 3 shows the processes performed by an EPROM writer according to the invention.

[0013] FIG. 4 s hows the detailed procedures involved in the modification of machines codes in accordance with the invention.

[0014] The present invention relates to a method of directly modifying the machine code according to the defective memory locations, such that when the executable machine code are written into the memory, the defective memory-cell locations are functionally bypassed. The invention is most useful and efficient in a write-once, execute-many-times, microprogram applications.

[0015] The present invention also relates to a system, built upon a code-modifying engine, for automatically modifying the machine code according to the defective memory-cell locations and according to a particular programming language instruction sets (e.g., 80×86 instruction sets), such that the modified machine code performs the identical functions and routines while functionally bypassing the defective memory-cells.

[0016] Before implementing the invention, other than the original machine code, the insertion-point table and the address referencing table are obtained first by any method including operator's judgment. Table 1 an example of a machine code with its corresponding machine code address and the corresponding assembly instructions.

[0017] The insertion-point table is an assembly of the machine code addresses at which additional code can be inserted without changing the functionality of the instruction steps of the original computer program. The acceptable insertion-point include the beginning of a machine-code instruction step, or the beginning of the byte position allocated for the definition of a symbol in the data segment, or the beginning of a stack allocation in the stack segment. The table 4 shows an example of a complete insertion-point table for the machine code shown in Table 1. In this example, an insertion point can be at the beginning of a data declaration (insertion type=1) or the beginning of an instruction step (insertion type=2). Alternatively, an insertion point table may include only a subset of those insertion points shown in the Table 4.

[0018] In machine-code programming, the relative address technique is frequently used. Other than the relative address technique, the absolute address technique is also used in address referencing in micro-programming. The address referencing table is an assembly of the machine code addresses at which an address is referred either by the relative address technique or the absolute address technique. Each entry in the table includes information regarding the number of bytes of contents corresponding to that address, the machine-code address referred to in the instruction and the type of the address referencing. Table 3 shows the address referencing table corresponding to the machine code shown in Table 1. When the machine code is available, a disassembly process is performed first by the operator to obtain its assembly form. From assembly language instruction, the insertion-point table and the address-referencing table may be obtained straightforward. There are a number of instructions typically involve address-referencing, for example, jump related instructions like JMP, JZ, JNZ; loop related instructions like LOOP; subroutine-calling related instructions like CALL, etc.

[0019] The general concept of the present invention is illustrated in FIG. 1. In FIG. 1, it shows a procedure by which a memory tester tests a memory chip for obtaining the defective memory-cell locations, modifies the machine code according to the list of defective memory-cell locations, and then writes the modified machine code into the memory. In block 10, memory test by any well known method is performed. If defective memory-cells are found in block 11, in block 12, an address list of the defective memory-cells is obtained. In block 13, based on the address list from block 12 and the original machine code from block 16, the insertion-point table from block 17, and the address-referencing table from block 18, a routine of the present invention directly modifies the machine code. The modified machine code, shown in block 14, will functionally bypass defective memory-cell addresses upon program execution. Afterwards, in block 15, the modified machines code are written into the memory. On the other hand, if no defective memory-cell is found in block 11, then the present invention directly writes the original machine code, from the block 16, into the memory in the block 15.

[0020] For non-volatile memories, such as an EPROM, a microprogram is typically written into the EPROM by a well known EPROM writer. It is known that the information stored in non-volatile memories are retained even when power is OFF. One can use the merit to store the list of defective memory-cell address as the header file at the pre-defined, i.e. the beginning or the ending addresses of the non-volatile memory. An EPROM writer can then obtain the defective memory-cell locations directly by reading the header file information stored in predefined memory addresses of the EPROM. FIGS. 2 and 3 show this approach designed for EPROM.

[0021] FIG. 2 shows the processes performed by a memory tester testing a non-volatile memory, e.g. EPROM, and then writing the defective memory-cell address information as a header file into the non-volatile memory. In block 20, memory test by any well known method is performed. If defective memory-cells are found in block 21, in block 22, an address list of the defective memory-cells is obtained. In block 23, the defective memory-cell address information is written as a header file into a pre-defined memory addresses of the tested EPROM, shown in block 29. If no defective memory-cells are found in block 21, a special information is optionally written into the header file to reflect this non-defective situation.

[0022] FIG. 3 shows a process performed by an EPROM writer which reads the defective memory-cell locations from the header file of the EPROM memory, modifies the machine code according to the list of defective memory-cell locations contained in the header file, then writes the modified machine code into the EPROM. In block 30, the process reads the header file from the EPROM to obtain the list of defective memory-cell addresses. In block 33, based on the address list from block 30, the original machine code from block 36, the insertion-point table from block 37, and the address referencing table from block 38, the present invention directly modifies the machine code in block 33. The modified machine code obtained, shown in block 34, will functionally bypass defective memory-cell addresses upon program execution. In block 35, the modified machines code are written into the EPROM.

[0023] The details of the procedures involved in the modifications of Machine Codes are disclosed in FIG. 4. Having the list of defective memory-cell address, the original machine code and the insertion point table, the process first in block 40 resets the variable of accumulated-insertion-byte to zero.

[0024] In block 41 the process checks if a next defective memory-cell address is found. If no, the process then jumps to block 50.

[0025] In block 42 the process subtracts the defective memory-cell address by the value of accumulated-insertion-byte to calculate a corresponding-code-address. The corresponding-code-address is the original memory-cell address at which the machine code stored will fall into this defective memory-cell address considered when the accumulated insertion bytes are effected.

[0026] In block 43 the process determines an appropriate insertion point preceding the corresponding-code-address together with the insertion type. If the insertion type for the chosen insertion point is 2, the insertion point needs to be at least two byte addresses lower than the corresponding-code-address. No such restriction is required if the insertion type is 1.

[0027] When there are adjacent defective memory-cell addresses, it is of advantage to jump across them altogether by one inserted jump step.

[0028] In block 44 the process adjusts the defective memory-cell address and the corresponding-code-address if adjacent defective memory cell addresses exist. The amount of N memory-cells following the defective memory-cell address need to be good memory-cells, where N=1 if insertion type equals 1, and N=2 if the insertion type equals 2. If this is not true, then the process increments the values of defective memory-cell address and the corresponding-code-address respectively by one until this requirement becomes true.

[0029] In block 45 the process calculates the number of bytes to be inserted at the insertion point. The number of bytes to be inserted is m≧[corresponding-code-address]−[insertion point address]+1.

[0030] In block 46 the process updates the accumulated-insertion-byte by the following equation. Accumulated-insertion-byte←Accumulated-insertion-byte+No of bytes to be inserted in block 45.

[0031] In block 47, the insertion code is constructed. If the insertion type equals 1, the insertion code can be any data for filling the bytes to be inserted. In a preferred embodiment, “00” is used. If the insertion type equals 2, then the first instruction of the insertion code is related to the machine code for jumping “m” bytes. Using 8086 code as an example, the first byte would be “EB”, the second byte would be kk, where kk=m−2. And since the following bytes will be skipped during program execution, in principle, it can be any data. In a preferred embodiment, the machine code corresponding to NOP is used. For 8086 microprocessors, the machine code corresponding to NOP is “90”.

[0032] When no more defective memory-cell is found in block 41 during the loops from blocks 41 to 47, in block 50, the process inputs the address referencing table. Afterwards, the process modifies the content of the instruction within the machine code involving the address referencing based on the address-referencing table to take into account of the effect of insertion of additional bytes of machine code mentioned above.

[0033] For absolute address referencing, the process increases the content at the machine code address “Addr1” specified in the Address-Referencing Table by x, wherein x is the total number of insertion bytes preceding the absolute code-address referenced. For relative address referencing, the process increases the content at the machine code address “Addr1” specified in the Address-Referencing Table by y, wherein y is the total number of insertion bytes between “Addr1” and “Addr2” in the relative code-address referenced.

[0034] In block 51, the process checks if a next address referencing entry is found. If it is, in block 52, the process changes content of code to reflect the influence of insertion bytes over the address-referencing. After completion, the process goes back to block 51. When no more entry is found in block 51, the process goes to block 53. In block 53, based on the information obtained in block 52, the process performs the creation of the modified machine code.

[0035] Alternatively, this procedure can be implemented within the block 52. In other words, once the information is obtained in block 52, the process immediately creates the modified code. If this alternative is adopted and no more address referencing is found in block 51, the process directly goes to block 54.

[0036] Table 5 shows how the modified machine code is generated based on the list of Defective memory-cell Address of Table 2, the Address-Referencing table of Table 3, the Insertion-Point Table in Table 4 and the original machine code in Table 1. After the Accumulated_insertion_byte is reset to 0 in block 40, the loop from block 41 to block 47 are executed three times. The detailed results of these three passes are described in the followings.

[0037] FOR THE FIRST PASS:

[0038] 11. The next defective memory-cell address=0002.

[0039] 12. The corresponding-code-address=0002−0=0002.

[0040] 13. The appropriate insertion point=0001, with insertion type=1.

[0041] 14. Adjust the defective memory-cell address and the corresponding-code-address by zero.

[0042] 15. The number of bytes to be inserted is 0002−0001+1=2.

[0043] 16. The Accumulated_insertion_bytes=0+2=2.

[0044] 17. The insertion code to be “00” and “00” based on the insertion type of 1.

[0045] FOR THE SECOND PASS:

[0046] 21. The next defective memory-cell address=001D.

[0047] 22. The corresponding-code-address=001D−2=001B.

[0048] 23. The appropriate insertion point=0019, with insertion type=2. (Note 001A is also an insertion point, but it is less than 2 byte away from 001B, and therefore can not be used for Type 2 insertion.)

[0049] 24. Adjust the defective memory-cell address and the corresponding-code-address by zero.

[0050] 25. The number of bytes to be inserted is 001B−0019+1=3.

[0051] 26. The Accumulated_insertion_bytes=2+3=5.

[0052] 27. The insertion code to be “EB” “01” and “90,” where the second byte 01 is equal to “m−2”=“3−2”=“01”.

[0053] FOR THE THIRD PASS:

[0054] 31. The next defective memory-cell address=0028.

[0055] 32. The corresponding-code-address=0028−5=0023.

[0056] 33. The appropriate insertion point=0020, with insertion type=2.

[0057] (Note 0022 is also an insertion point, but it is less than 2 byte away from 0023, and therefore can not be used for Type 2 insertion.)

[0058] 34. Adjust the defective memory-cell address and the corresponding-code-address respectively by each incrementing 1. This is due to another defective memory-cell at memory address 0029, which is less than two bytes away from the current defective memory-cell address 0028. As a result, the defective memory-cell address is incremented by 1 to 0029, and the corresponding-code-address is also incremented by 1 to 0024.

[0059] 35. The number of bytes to be inserted is 0024−0020+1=5.

[0060] 36. The Accumulated_insertion_bytes=5+5=10.

[0061] 37. The insertion code to be “EB” “03” “90” “90” and “90,” where the second byte “03” is equal to “m−2”=“5−2”=“03”.

[0062] After the above three passes are executed, there are no defective memory-cell is found any more, and the process goes to the block 50. The following statuses are encountered due to the Address-Referencing table shown in Table 3.

[0063] The first one from the Address-Referencing Table is an absolute-address referencing at the machine-code address of 0016, where two bytes are used to represent the absolute machine-code address 0008 referenced. The content of the two bytes at the machine-code addresses 0016 and 0017 are “08” “00” (lower byte first in 8086 machine code) to represent an absolute address 0008. Since the accumulated insertion bytes is 2 prior to the machine-code address, 0008, the content 0008 is increased by 2 to be “0A” “00” representing the new address 000A.

[0064] The next one from the Address-Referencing Table a relative-address referencing at the machine-code address of 001F, where one byte is used to represent the relative machine-code address 0024 referenced. The content of the one byte at the machine-code addresses 001F is “04.” Since the total insertion bytes is 5 between Addr1 of 001F and Addr2 of 0024, the memory content “04” is increased by 5 to “09” accordingly.

[0065] After no more entry is left on the list of the Address-Referencing Table, the process stops.

[0066] Table 6 shows the modified machine code based on the procedure outlined in Table 5 and described above. As shown in Table 6, the defective memory-cell addresses 0002, 001D , 0028 and 0029 are all bypassed when the modified machine code is loaded in the memory for execution. The corresponding Assembler code is also listed for reference.

[0067] Although the preferred embodiment of the invention are recited using assembly language and machine code of 80×86 microprocessor, it is apparent, the spirit and essence of the invention, which is defined by the following appended claims, is not limit to any specific machine or any specific programming language.