专利名称：用于高级微处理器的翻译存储器保护装置的制作方法
技术领域：
本发明涉及计算机系统，特别是涉及防止当第一指令集的指令在存储器被覆盖时从第一指令集翻译为另一指令集的指令的误用的方法和装置。
背景技术：
在计算机上运行着成千上万针对特定微处理器系列设计的应用程序。其中为利用“X86”系列微处理器(包括Intel8088、Intel 8086、Intel 80186Intel 80286、i386、i486以及随后发展的各种奔腾系列微处理器，它们都是位于加州Santa Clara的Intel公司设计和制造)的计算机(通常称为“IBM兼容个人电脑”)而设计的程序数量最多。针对利用其它系列处理器的计算机也设计有许多程序。由于运行在这些计算机上的应用程序非常多，所以能够为这类计算机(特别是处理X86程序的计算机)所用的微处理器拥有巨大的市场。微处理器市场不仅容量巨大而且获利丰厚。
虽然能够运行大量应用程序的微处理器市场容量巨大而且获利丰厚，但是设计新的有竞争力的微处理器却不那么容易。例如，虽然X86系列的微处理器已经问世多年并且在大多数销售和使用的计算机内都包含这些处理器，但是也只有少数成功的有竞争力的微处理器能够运行X86程序。其中的原因是多方面的。
为了取得成功，微处理器必须能在不高于现有微处理器开销的前提下，与现有处理器一样快地运行针对现有系列处理器设计的所有程序(包括操作系统和已有程序)。此外，为了在经济上取得成功，新的微处理器必须至少在某一方面胜过现有的处理器，从而使买主有选购新微处理器的理由。
要做到使微处理器运行速度与现有微处理器一样快是困难和昂贵的。处理器通过诸如加载、移位、相加、存储和类似的低层次操作之类的基本操作执行指令并且在执行应用程序提供的指令时仅仅响应这类基本操作。例如在诸如X86之类被设计为运行复杂指令集计算机(CSIC)的处理器中，指令在较高的级别上表示待执行的处理，该处理器包含存储所谓微指令的只读存储器(ROM)。每条微指令包含一串基本指令，依照顺序执行这些基本指令将得到高级CISC指令所命令的结果。典型的“A加B”CISC指令经过译码后在ROM内查找地址，执行“A加B”功能指令的微指令就存储在ROM内。微指令加载后，其基本指令按照顺序执行，从而完成“A加B”指令的执行。在这类CSIC计算机中，微指令内基本操作在程序执行过程中绝对不可能发生变化。每条CISC指令只能通过指令译码、寻址和提取微指令以及按照微指令提供的顺序运行基本操作序列完成运行过程。微指令每次运行时都必须遵循同一顺序。
当今运行X86应用程序的处理器利用大量的技术，在合理的性价比前提下提供最快的处理速度。任何采用已知硬件技术提高处理器速度的新处理器都必然会增加处理硬件的复杂度。这增加了硬件成本。
例如超标量微处理器(superscalar)，为了同时执行两个以上的操作，它使用多条处理通道，对此需要一系列额外的需求。在最底层级别上，简单的超标量微处理器将每条应用指令译码为执行应用指令功能的微指令。随后，如果两条微指令不需要相同的硬件资源并且一条微指令的执行不依赖于待处理的另一条微指令的结果，则简单超标量微处理器将这两条微指令安排为同时执行。
更加高级的超标量微处理器一般将每条应用指令译码为一系列的基本指令，从而以最有效率的执行次序重新排序和安排这些基本指令的执行。这需要每条基本操作都能单独寻址和存取。为了完成重新排序，处理器必须确保需要其它基本指令数据结果的基本指令在其他指令产生所需数据之后执行。这类超标量微处理器必须确保同时执行的两条基本指令不需要使用同一硬件资源。而且还必须在完成转移操作之前解决条件转移。
因此超标量微处理器需要大量的硬件来比较基本指令之间的相互关系，重新排序和安排基本指令的顺序执行任何指令。随着处理通道数的增加，完成这些超标量加速技术的硬件数量和成本将以近似二次方的速度增加。所有这些硬件需求都增加所涉及电路系统的复杂性和成本。在处理微指令过程中，当每次执行一条应用指令时，超标量微处理器都必须使用比较复杂的寻址和提取硬件来提取每条基本指令，都必须根据其它基本指令和硬件使用状态重新排序和重新安排这些基本指令，并且随后还必须执行所有重新安排后的基本指令。由于每次执行一条应用指令时都必须通过整个硬件序列，所以限制了超标量处理器能够执行指令的速度。
即使利用各种硬件技术提高了处理速度，由此带来的硬件复杂性也大大增加了这类微处理器的成本。例如，Intel i486 DX4处理器采用大约150万个晶体管。但是如果要在诸如Intel奔腾之类的基本超标量处理器中通过增加硬件来利用两条通道完成指令处理所需的依存度检查和执行安排，则需要300多万个晶体管。在Ihtel Pentium Pro微处理器中，为了能重新排序源自不同目标指令的基本指令，提供预测执行，允许寄存器更名和提供转移预测，增加到超过600多万个晶体管。由此可见，为提高运算速度而增加硬件已使最新一代微处理器的晶体管数量出乎寻常地增加。
即使采用这些已知的技术，但是由于现有微处理器制造商已经采用了绝大部分经济可行的技术来提高现有微处理器的运行速度，所以也不可能制造出更快的微处理器。这样，设计更快的处理器就成了一项非常困难和费钱的工作。
降低处理器成本也是非常困难的。如上所述，制造具有足够能力处理器的硬件加速技术非常昂贵。如果要设计一种新的处理器，必须拥有生产硬件的设备。由于芯片制造商一般不会投资小批量器件，所以难以获得这类设备。生产芯片制造设备所需的资本投资如此巨大，以致于超出了大多数公司力所能及的范围。
即使设计出的新处理器能够至少以竞争处理器同样快的速度运行所有针对竞争处理器设计的应用程序，竞争处理器在价格中也包含了足够的利润，从而确保其能面对竞争对手作大幅度削价。
虽然通过增加硬件复杂度来设计富有竞争力的处理器是非常困难的，但是可以有另一种运行针对某一特定系列微处理器(目标微处理器)设计的应用程序(目标应用程序)的方法，它在另一种更快的微处理器(主微处理器)上用软件仿真目标微处理器。由于这仅仅需要增加一定形式的仿真软件以在更快的微处理器上运行应用程序，所以是一种成本日趋低廉的方法。仿真器软件将针对目标处理器系列编写的应用程序目标指令改写为能够被主微处理器执行的主指令(host instruction)。随后这些被改写的指令在较快主微处理器上操作系统的控制下运行。
有许多种不同的设计可以使目标应用程序运行在处理器速度快于目标计算机处理器的主计算机上。由于从理论上讲，精简指令集(RISC)微处理器更为简单而且速度较其它类型处理器更快，所以利用仿真软件执行目标程序的主计算机都采用RISC微处理器。
但是即使利用仿真器软件的RISC计算机系统能够运行X86(或其它)程序，它们的运行速度通常也明显慢于X86计算机系统运行同一程序的速度。而且这些仿真器程序常常无法运行所有或大量现有的目标程序。
仿真器程序无法象目标微处理器那样快地运行目标程序的原因相当复杂并且需要对不同的仿真操作有所了解。
图1包括一系列的示意图，它们表示不同类型微处理器执行目标应用程序的方式。
在图1(a)中，诸如Intel X86微处理器之类的典型CISC微处理器运行着设计在目标微处理器运行的目标应用程序。如图所示，应用程序运行在利用CISC操作系统(例如X86计算机使用的MS DOS、Windows3.1、Windows NT和OS/2)的CISC处理器上，这些操作系统提供了访问计算机硬件的接口。典型情况是选择应用程序的指令，只通过操作系统提供的访问使用计算机设备。因此操作系统处理控制器允许应用程序访问计算机存储器和各种输入/输出设备。目标计算机包含能够被操作系统识别的存储器和硬件，并且目标应用程序对操作系统的调用使操作系统设备驱动程序在目标计算机定义的设备上产生预期的操作。应用程序的指令在处理器上执行，它们被变换为可以被处理器执行的操作，这些操作由微代码或汇编为微代码的更加基本的操作具体实现。如上所述，每次执行复杂的目标指令时，指令都调用以微代码(或同一基本操作组)形式存储的同一子程序。执行的总是同一子程序。如果处理器是超标量的，则执行目标指令的这些基本操作常常可以被处理器以上述方式，利用各种处理通道进行重新排序、重新安排和执行；但是子程序仍然被提取和执行。
在图1(b)中，诸如用于苹果Macintosh计算机中的PowerPC之类的典型RISC微处理器运行着针对图1(a)CISC处理器运行设计的同一目标应用程序。如图所示，目标应用程序至少借助部分目标操作系统运行于主处理器上以响应目标应用程序生成的一部分调用。典型的是对目标操作系统应用类部分的调用，用来在显示器上提供图形接口和通常是应用类程序的小型工具程序。目标应用程序和目标操作系统的这些部分由诸如SoftPC之类的软件仿真器变换，它将目标应用程序和应用类目标操作系统提供的指令分解为主处理器及其主操作系统能够执行的指令。主操作系统提供了访问RISC计算机的存储器和输入/输出硬件的接口。
但是主RISC处理器及其RISC计算机中相关的硬件设备通常与这样一些设备有相当大的差异，它们与针对目标应用程序而设计的处理器相关；并且目标应用程序提供的各种指令被设计为使目标操作系统的设备驱动程序在访问目标计算机各部分时协同工作。因此对于将目标应用程序指令变换为主操作系统能够利用的基本主指令的仿真程序而言，它必须在某种程度上将操纵目标计算机内硬件设备的操作与主系统硬件设备能够实现的操作联系起来。由于目标设备并不等同于主计算机的设备，所以通常需要由仿真器软件生成响应目标应用程序指令的虚拟设备来完成主系统无法实现的操作。有时候仿真器需要通过主操作系统生成从这些虚拟设备至主硬件设备的链接，这些主硬件设备虽然是真实存在，但是要由主操作系统按照不同的方式寻址。
由于众多的原因，以这种方式运行的目标程序速度较慢。首先，来自目标应用程序和目标操作系统的每条目标指令都必须由仿真器变换为主处理器使用的主基本功能。如果目标应用程序是针对诸如X86之类的CSIC机而设计的，则目标指令是变长度的并且相当复杂，因此将它们变换为主基本指令就相当费事。源目标指令首先被译码，并确定构成目标指令的主基本指令序列。随后确定每串基本主指令序列的地址，提取每串基本主指令序列，并按照顺序或者不按照顺序执行这些基本主指令。每次执行指令时都必须由仿真器将目标应用程序和操作系统指令变换为主处理器理解的主指令，这需要大量额外的步骤，因此减慢了仿真处理的速度。
其次，许多目标指令与由特定硬件设备执行操作有关，这些特定硬件设备在目标计算机中起着特殊的作用，但在主计算机中却不存在。为了执行该类操作，仿真软件必须通过已有的主操作系统与主计算机的硬件设备实现软件连接或者配备一台虚拟硬件设备。用软件仿真另一种计算机硬件是非常困难的。仿真软件必须生成各种目标应用调用主操作系统的虚拟设备；并且每台虚拟设备都必须向实际主设备提供调用。硬件设备仿真要求在目标指令使用设备时从存储器中提取表示指令所需虚拟设备代码并进行运行以实现设备功能。解决问题的这些方法在执行指令序列时都额外增加了一系列的操作。
仿真问题的复杂化是目标应用要解决各种意外事件的结果，为了使计算机系统运行，目标计算机的硬件和目标操作系统要对这些意外事件作出处理。当目标计算机运行期间的异常产生时，一般必须通过调用微代码序列完成保存发生意外事件时刻计算机状态的操作，正确的异常处理必须被恢复(handle)，异常必须被处理，并且必须找到程序继续运行下去的正确入口。有时候这要求程序返回至处理意外事件之处目标计算机的状态，而其它时候进入意外事件句柄提供的转移。在任一情况下，都必须在某种程度上对完成这些操作所需的目标计算机硬件和软件进行仿真。由于必须在发生意外事件时可以得到正确的目标状态以供适当执行，仿真器必须始终精确跟踪该状态以准确响应这些意外事件。在现有技术中，这要求每条指令的执行必须按照目标应用程序提供的顺序，因为只有这种方式能够保持正确的目标状态。
而且现有技术的仿真器出于其它原因，总是需要保持目标应用程序的执行顺序。目标指令可以有两种，一种作用于存储器而另一种作用于存储器映射的输入/输出(I/O)设备。如果不执行指令是无法知道操作是作用于存储器还是存储器映射I/O设备的。当指令在存储器上运行时，可以作优化和重新排序并且这大大有助于提高系统运行速度。但是作用于I/O设备的操作常常必须按照精确的顺序进行，这些操作必须按照该顺序编程而不能省略任何步骤，否则可能对I/O设备的操作产生一些不利的影响。例如特殊的I/O操作可能会清除I/O寄存器的内容。如果操作不按照顺序进行从而清除了寄存器内仍然需要的值，则操作结果可能不同于目标指令所命令的那样。如果没有区分存储器和存储器映射I/O的装置，就需要将所有的指令都象处理作用于存储器映射I/O的指令那样处理。这大大限制了优化所能达到的性能。由于现有技术的仿真器缺少检测被寻址存储器性质的装置和从这类故障恢复的装置，所以需要顺序处理目标指令，就好象每条指令都作用于存储器映射I/O那样。这极大地制约了主指令的优化的可能性。
另一个限制现有技术仿真器优化主代码能力的问题源于自修改代码。如果目标指令被变换为主指令序列，而主指令序列又被回写从而改变了源目标指令，则主指令不再有效。结果仿真器必须始终作检验以确定是否有目标代码区域的存储。所有这些问题都使这种类型的仿真比在目标处理器上运行目标应用程序慢得多。
图1(b)所示另一种类型的仿真软件实例在题为“Talisman快速而精确的多计算机模拟”(R.C.Bedichek，麻省理工学院计算机科学实验室)的文章中有所论述。这是更为完整的转换实例，它可以仿真完整的研究系统并运行研究目标操作系统。Talisman采用主UNIX操作系统。
在图1(c)中示出了另一种仿真实例。在该实例中，用于苹果Macintosh计算机的PowerPC微处理器正在运行针对莫托罗拉68000系列CISC处理器设计的目标应用程序，后者用于早期的Macintosh计算机；这样做的目的是为了使苹果原有的程序能够在带RISC处理器的Macintosh计算机上运行。显而易见，目标应用程序至少借助部分目标操作系统运行于主处理器上以响应目标操作系统应用类部分的调用。软件仿真器将目标应用程序和应用类目标操作系统程序提供的指令分解为主处理器及其主操作系统能够执行的指令。主操作系统提供了访问主计算机的存储器和输入/输出硬件的接口。
但是主RISC处理器及其主RISC计算机中相关的设备与配备莫托罗拉CISC处理器的设备有相当大的差异；并且各种目标指令被设计为在访问目标计算机各部分时与目标CSIC操作系统协同工作。因此仿真程序必须将操纵目标计算机内硬件设备的操作与主系统硬件设备能够实现的操作联系起来。这需要由仿真器生成响应目标应用程序指令的软件虚拟设备并通过主操作系统生成从这些虚拟设备至主硬件设备的链接，这些主硬件设备虽然是真实存在，但是要由主操作系统按照不同的方式寻址。
由于与图1(b)仿真同样的原因，以这种方式运行的目标程序运行速度较慢。首先，来自目标应用程序和目标操作系统的每条目标指令都必须经过指令提取才能变换；并且每次执行指令时从该指令导出的所有主基本功能都必须按照顺序运行。其次，仿真软件必须生成每个目标应用程序调用主操作系统的虚拟设备；并且每台虚拟设备都必须向实际主设备提供调用。第三，仿真器必须象处理直接作用于存储器映射I/O设备的指令那样保守地处理所有指令，否则就有发生无法恢复的意外事件的危险。最后，仿真器必须始终保持正确的目标状态并总是要在确定是否存储目标代码区域之前检查存储操作。所有这些要求都削弱了仿真器对运行在主处理器上代码作重大优化的能力并且使这种仿真的速度远远慢于目标应用程序在目标处理器上的运行速度。在非常乐观的情况估计仿真速度也要低于现有处理器的四分之一。通常情况下，这种仿真软件在能够运行为另一种处理器设计的应用程序的能力只是有用而非基本用途的情况下，很难找到它的使用价值。
在图1(d)中示出一种在主处理器上仿真目标应用程序的特殊方法，它为非常少数的一系列目标应用程序提供了较好的性能。目标应用程序为仿真器提供指令，该仿真器将这些指令变换为主处理器和主操作系统的指令。主处理器为数字设备公司的Alpha RISC处理器，而主操作系统为微软的NT。只能在这种系统上运行的目标应用程序是为采用Windows WIN32s兼容操作系统的目标X86处理器而设计的32位应用程序。由于主操作系统和目标操作系统几乎是相同的，它们设计成处理相同的指令，所以仿真器软件可以非常方便地变换指令。而且主操作系统也已设计为响应目标应用程序产生的相同调用，所以生成的虚拟设备数量大大减少。
虽然在技术上它是一种使目标应用程序运行于主处理器上的仿真系统，但却是一种非常特殊的情况。在这种情况下仿真软件运行于已经为运行相似应用程序而设计好的主操作系统上。它使得来自目标应用程序的调用能够更为简单地指向主处理器和主操作系统正确的设备。更为重要的是，该系统只能运行32位Windows应用程序，其在所有X86应用程序中所占的数量不到1％。而且该系统只能在一种操作系统上，即Windows NT上运行应用程序；而X86处理器可运行针对大量操作系统而设计的应用程序。因此就本说明书前面所表述的含义而言，这样的系统不具备兼容性。因此运行这类仿真器的处理器是不能认为是富有竞争力的X86处理器。
在图1(e)中示出另一种仿真方法，它利用软件在识别不同指令集的计算机上运行为第一指令集编写的应用程序部分。这种形式的仿真软件一般由程序员使用，他们将一个应用程序从一种计算机系统移植到另一种计算机系统上。典型的情况是目标应用程序针对除运行仿真器的主机以外的一些目标计算机而设计。仿真器软件分析目标指令，将这些指令翻译为可以在主机上运行的指令，并且将这些主指令存入高速缓冲存储器内供再次使用。这种动态翻译和高速缓存可以使应用程序部分运行得非常快。这种形式的仿真器一般与软件跟踪工具一起使用，该工具提供了正在运行的目标程序详细的运行信息。跟踪工具的输出又被用来启动分析程序，对跟踪信息进行分析。
为了确定代码实际上是如何工作的，这种类型的仿真器与主机上的主操作系统协同运行，配备了主操作系统未提供的虚拟硬件，并且将设计应用软件的计算机的操作映射到主机硬件资源以执行正在运行的程序的操作。这种硬件的软件虚拟化和对主计算机的映射可能非常慢并且很不完善。
而且由于常常需要多条主指令执行一条目标指令，所以可能产生包括故障和陷井在内的意外事件，这需要目标操作系统的意外事件句柄，并且使主机在与目标指令边界无关的位置上中止处理主指令。当发生这种情况时，由于主处理器和存储器的状态不正确，所以无法正确处理意外事件。如果出现这种情况，仿真器必须停止运行并重新运行并返回跟踪产生意外事件的操作。因此虽然这种仿真器能够非常快地运行目标代码序列，但是却没有办法从这些意外事件中恢复过来，因此无法快速运行应用程序中任何相当大的一块。
由于仿真器、跟踪器和相关的分析器所完成的功能是直接产生新的程序或者将旧程序移植到另一种机器上，因而就仿真器软件运行速度而言很少有定论，因此这不是这种形式仿真器固有的问题。即，程序员通常对仿真器生成的代码在主机上运行得有多快并不感兴趣，他们感兴趣的是仿真器是否能生成可在为其设计的机器上执行并在该机器上运行快速的代码。因此除了编程目的以外，这种类型的仿真软件不能提供使第一指令集编写的应用程序能运行在不同类型的微处理器上的方法。这种仿真软件的实例在题为“ShadeA Fast Instruction-Set Simulator for Execution Profiling”(Cmelik和Keppel)的文章中有所论及。
因此需要提供一种具有竞争力的微处理器，它比现有技术的微处理器更快更便宜，但是又与为现有技术微处理器运行各种可用操作系统而设计的目标应用程序完全兼容。
具体而言需要提供一种主处理器，它包含提高处理器功能速度的电路系统。
发明内容
因此本发明的目标是提供一种带有提高微处理器性能的装置的主处理器，与现有技术的微处理器相比，本发明的微处理器价格便宜并且是兼容的，而且能够比其他微处理器更快地运行为其他微处理器设计的应用程序和操作系统。
为了实现本发明的各种目标，本发明的装置和方法试图写入包含目标指令的存储器地址，目标指令被翻译为主处理器执行的主指令，它包含的步骤为标记包含被翻译为主指令的目标指令的存储器地址；当试图向存储器地址写入时检测被标记的存储器地址；以及通过保护存储器地址处的目标指令直到确认与存储器地址相关的翻译在更新之前不用时来检测被标记的存储器地址。
通过以下附图对本发明的详细描述可以更好地理解本发明的各种目标和特点，在附图中相同的单元采用相同的标记。
附图的简要说明图1(a)-(e)为按照现有技术设计的微处理器操作方式的示意图。
图2为按照本发明设计的微处理器的框图，该处理器可运行针对不同微处理器设计的应用程序。
图3为图2所示微处理器某一部分的示意图。
图4为寄存器文件的框图，该寄存器文件在按照本发明设计的微处理器中使用。
图5为按照本发明设计的门控存储缓冲器的框图。
图6(a)-(c)示出了用于现有技术各种微处理器和按照本发明设计的微处理器的指令。
图7示出了按照本发明设计的微处理器软件部分实现的方法。
图8示出了按照本发明设计的微处理器软件部分实现的另一种方法。
图9为改进的计算机系统的框图，它包含了本发明。
图10为图3所示微处理器某一部分的框图。
图11为图3微处理器中翻译查找旁路缓冲器的更为详细的框图。
记号和术语以下某些详细描述部分将借助对计算机存储器内数据位操作所作的符号化表示。这些描述和表达形式是数据处理领域内技术人员向同行表述其工作内容最为有效的方式。这些操作需要对物理量施行物理操作。虽然并非必要，但是通常情况下这些物理量采用可以存储、转换、组合、比较和其他处理方式的电学或磁学信号形式。为方便起见，主要是通用的原因，这些信号被称为位、值、元素、符号、字符、项、数字等。但是应该认识到，所有这些以及相似的术语都与合适的物理量相联系并且仅仅是为方便表示这些物理量而采用的标记。
所完成的控制通常用诸如加法或比较之类的术语表示，它们一般与人类的智力活动有联系。在构成本发明的大多数操作中，人类的这种能力并不是必不可少或需要的；这些操作是机器操作。完成本发明操作的有用机器包括通用数字计算机或其它类似设备。在所有情况下，操纵计算机的操作方法与计算方法本身之间应视为是有区别的。本发明涉及操作计算机的方法和装置，这种计算机处理电学或其它(例如机械、化学)物理信号以生成其它所需的物理信号。
在下面的描述中，由于大多数的仿真器都运行X86应用程序，所以为了举例说明操作细节，在某些情况下将目标程序看作为在X86微处理器上执行的程序。但是目标程序可以为在任意目标计算机系列上运行而设计。它们包括目标虚拟计算机，例如Pcode机、Postscript机或者Java虚拟机。
实施发明的较佳方式本发明有助于克服现有技术存在的问题并且提供了一种速度比现有技术更快的微处理器，它能够运行所有(大量现有技术微处理器都可以运行的)操作系统下的所有软件，但是价格又低于现有技术的微处理器。
与采用更为复杂的硬件加快运算速度的做法不同，本发明一方面采用比现有技术微处理器简单得多的增强硬件处理部分(在本说明书中称为“词态(主机(morph host)”)，另一方面采用一种仿真软件(称为“代码词态化软件(code morphing software”)，二者结合成为比已知的竞争性微处理器功能更强大的微处理器。具体而言，词态主机是一种包含硬件增强的处理器，当发生意外事件或者错误时它立即恢复为目标计算机的状态，而代码词态化软件将目标程序的指令翻译为词态主机的词态主机指令，并在需要时用正确的目标状态代替工作状态以响应意外事件或错误，从而进行正确的重新翻译。代码词态化软件也可以包括提高处理速度的各种进程。与所有速度极快的现有技术微处理器通过提供硬件来提高处理速度的做法不同，改进的微处理器借助代码词态化软件在可以选择的阶段允许大量的加速增强技术实现。在代码词态化软件中运用提速技术使得可以采用复杂程度较低但运行速度比现有技术微处理器更快而价格大为降低的硬件实现词态主机。作为比较，在一个用包含Pentium Pro微处理器四分之一数量门电路的词态主机实现的本发明实施例中，运行X86应用程序的速度要快于Pentium Pro微处理器或者其它能够处理这类应用程序的已知微处理器。
代码词态化软件采用了某些技术，这些技术以前只是由程序员在设计新软件或仿真新硬件时采用过。词态主机包含硬件增强部分，它特别适合于充分利用代码词态化软件提供的加速技术。这些硬件增强部分允许代码词态化软件在更宽的指令范围内实现加速技术。这些硬件增强部分还允许代码词态化软件实现其它加速技术，这些技术在硬件处理器中不具备，且无法在硬件处理器内应用，除非花费巨额的代价。与现有技术微处理器执行本身的指令集的情形相比，这些技术明显提高了包含本发明的微处理器的速度。
例如，与增强型词态主机结合的代码词态化软件可以采用重新排列与重新安排由目标指令序列生成的基本指令的技术而无需增加太多的电路。由于可以一起重新排序与重新安排大量目标指令，所以可以采用其它的优化技术来减少处理器执行目标指令组所需的步骤数，使其少于其它运行目标应用程序的微处理器所需的一组目标指令。
与增强型词态主机组合起来的代码词态化软件快速将目标指令翻译为词态主机的指令并且将这些主指令存入存储器数据结构(在本说明书中称为“翻译缓冲器”)。使用保存翻译指令的翻译缓冲器可以再次调用指令而无需在每次执行每条目标指令时，重新运行冗长的进程，确定需要哪一条基本指令来实现每条目标指令，对每条基本指令作寻址、提取，优化基本指令序列，为每条基本指令分配资源，进行重新排序基本指令并执行每一基本指令(包含每次每个目标指令被执行)序列的每个步骤。目标指令一旦被翻译出来，它就可以从翻译缓冲器内再次调用并执行而无需无数这些步骤。
现有仿真技术的主要问题是无法高性能地处理目标程序执行期间产生的意外事件。如果在运行直接指向目标操作系统的目标应用程序时产生意外事件，情况更是如此，此时为了正确处理意外事件和执行随后的指令，必须有发生意外事件时正确的目标状态供使用。因此仿真器被迫始终精确跟踪目标状态并一直进行检查，以确定是否存储到目标代码区域。其它意外事件也会带来类似的问题。例如仿真器检测到已经被一些特定主功能替代的特定目标操作也可能产生意外事件。特别是目标处理器的各种硬件操作可以由仿真器软件提供的软件操作代替。此外，执行由目标指令导出的主指令的主处理器也可能产生意外事件。所有这些意外事件都有可能在仿真器试图将目标指令变换为主指令时或者在主处理器上执行主翻译时发生。高效的仿真必须提供一些从这些意外事件有效恢复的方式并且能够正确处理意外事件。现有技术均无法对所有被仿真的软件做到这一点。
为了克服现有技术的这些不足，在增强型词态主机中作了大量的硬件改进。这些改进包括门控(gated)存储缓冲器和许多新增加的处理器寄存器。新增的其中一些寄存器可以重新命名以缓解需要同一硬件资源指令的问题。新增的寄存器还可以维护一组处理主指令的主机或工作寄存器和一组保存目标处理器(它被用于目标应用程序的生成)正式状态的目标寄存器。目标(或影子)寄存器通过专用接口与与其等价的工作寄存器相连，专用接口使得称为“提交”的操作将所有工作寄存器的内容快速传递至正式目标寄存器，并使得称为“回退”的操作将所有正式目标寄存器的内容快速返回到与其等价的工作寄存器。门控存储缓冲器存储工作存贮器状态改变硬件“门电路”“未提交”一侧改变正式存储器状态变化硬件门电路“提交”一侧，这些提交的存储结果“排放”至主存储器。提交操作将门电路为非提交一侧的存储传递至门电路的提交一侧。新增的正式寄存器和门控存储缓冲器使存储器状态和目标寄存器状态在一条或一组目标指令被翻译和运行无误之后一起更新。
这些更新由代码词态化软件选择发生于完整的目标指令边界。因此，如果构成目标指令系列翻译的基本主指令由主处理器运行而未发生意外事件，则这些指令产生工作存储器存储和工作寄存器状态被传递至正式存储器和正式目标寄存器。这样，如果意外事件发生在处理主指令而此时又不在被翻译的一条或一组目标指令的边界上时，可以将最近更新(或提交)的目标寄存器原始状态再次调用至工作寄存器并转储门控存储缓冲器内未提交的存储器存储结果。如果发生的意外事件是目标意外事件，则可以一次重新翻译一条引起目标意外事件的目标指令并象目标微处理器执行目标指令那样依照顺序执行目标指令。当每条目标指令被正确无误地执行时，可以更新目标寄存器的状态；并且存储缓冲器内数据受到门电路的控制向存储器传送。随后，当运行主指令时再次发生意外事件时，目标计算机的正确状态由词态主机的目标寄存器和存储器保存；并且可以无延迟地正确处理操作。由于每条通过这种纠错翻译生成的新翻译结果是翻译或者交替转储(防止一次性或偶尔发生的诸如页面出错事件)完成的，所以可以高速缓存以供后面使用。这使得代码词态化软件与词态主机组合构成的微处理器能够比原先为其编写软件的处理器更快地执行指令。
应该指出的是，在利用本发明的微处理器执行目标程序的过程中，可能会发生许多不同类型的意外事件，它们需要不同方式处理。例如一些意外事件由产生一件意外事件的目标软件引起，该意外事件使用了目标操作系统意外事件句柄。使用这种意外事件句柄要求代码词态化软件包含仿真整个意外事件处理进程的子程序，包含任何由处理进程的目标计算机提供的硬件。这就需要代码词态化软件保存目标处理器的状态从而在处理完意外事件之后继续正确执行。某些意外事件(例如页面出错)需要在实现被翻译进程之前将数据送入新的存储器页面中，当意外事件处理之后它要求返回至被翻译进程的开始之处。其它意外事件实现了软件中硬件未提供的特殊操作。这些意外事件都要求意外事件句柄在处理完意外事件之后将操作返回翻译中的下一步骤。每种不同类型的意外事件都可以由本发明的微处理器有效处理。
此外，有些意外事件由主机硬件产生并且检测各种主机和目标机状态。有些意外事件的表现如同在普通微处理器上一样，而其它的则被代码词态化软件用来检测各种预测的故障。在这些情况下，采用上述状态保存和恢复机制的代码词态化软件将目标状态恢复至其最近的正式状态并将产生和保存新的翻译结果(或者再次使用先前生成的安全的翻译结果)，这避免了无效预测。随后执行该翻译结果。
词态主机包含新增的硬件意外事件检测机构，它与上述返还和重新翻译方法结合可以作进一步的优化。例如有一种装置，它将存储器从存储器映射I/O区分开来，另有一种装置，它通过保护地址或地址范围省却了存储器参照，由此可以在寄存器内保存目标变量。
在利用意外事件检测其它预测失效(例如操作是影响存储器还是存储器映射I/O)时，通过借助不同的存储器操作和不同的优化生成新的翻译结果来完成恢复工作。
图2为词态主机硬件的示意图，它正在运行与图1(a)上CISC处理器相同的应用程序。如图所示，微处理器包含上述代码词态化软件部分和增强型硬件词态主机部分。目标应用程序将目标指令载入代码词态化软件以将其翻译为词态主机能够执行的主机指令。与此同时，目标操作系统接收目标应用程序的调用并将调用转送至代码词态化软件。在微处理器的较佳实施例中，词态主机是一种超长指令字(VLIW)处理器，它设计有多条处理通道。图6(c)示出了这种处理器的总体操作。
在图6(a)-(c)中示出了适用于CISC处理器、RISC处理器和VLIW处理器的指令。显然CISC指令是变长度的并且可以包含多条更基本的操作(例如加载和相加)。另一方面，RISC指令是等长度的并且主要是基本操作。图示的VLIW处理器的一条超长指令包括CISC和RISC指令的每个更为基本的操作(例如加载、存储、整数相加、比较、浮点乘法和转移)和。如图6(c)所示，一起构成一条超长指令字的每条基本指令与其它基本指令并行地载入VLIW处理器其中一条处理通道或者存储器内以供处理通道和存储器并行处理。并行操作的所有结果都被转送至多端口寄存器文件。
可作为词态主机基础的VLIW处理器在结构上比上述其它处理器简单得多。它不包含检测结果依存性的电路或者重新排序、优化和重新安排基本指令的电路。与运行原先为其设计目标应用程序的处理器或者利用仿真程序运行目标应用程序的其它处理器相比，这使得可以在较高的时钟频率有更快的处理速度。但是这并不局限于VLIW处理器，诸如RISC处理器之类的任意类型处理器都可以实现同样的效果。
图2所示微处理器的代码词态化软件包括翻译机部分，它对目标应用程序的指令进行译码，将目标指令转换为词态主机能够执行的基本主指令，优化目标指令所需的操作，将基本指令重新排序和重新安排为词态主机的VLIW指令(翻译)并执行主VLIW指令。图7为翻译机操作示意图，它示出了代码词态化软件主循环操作。
为了加速包含代码词态化软件和增强词态主硬件的微处理器的运行速度，如图2所示，代码词态化软件包含翻译缓冲器。一个实施例的翻译缓冲器是一种可以在存储器内存储的软件数据结构；在特殊的实施例中也可以采用硬件高速缓存。翻译缓冲器被用来存储主指令，主指令实现了每一个目标指令的完整翻译。显而易见，一旦翻译出单条目标指令并对获得的主指令进行优化、重新排序和重新安排，所得到的主指令就被存储在翻译缓冲器内。构成翻译结果的主指令随后由词态主机执行。如果主指令的执行不发生意外事件，则无论何时需要实现目标指令的操作或需要指令时都可以再次调用该主指令。
如图7所示，由应用程序载入目标指令地址的微处理器词态化软件的典型操作是首先确定目标地址上的目标指令是否已经翻译。如果目标指令未被翻译，则提取该目标指令以及随后的目标指令，并且将它们译码、翻译并随后优化(可能是)、重新排序和重新安排为新的主翻译指令，并由翻译机将它们存储在翻译缓冲器内。如下可见，优化可以达到不同的程序。在本说明书中术语“优化”常常指的是加速处理的技术。例如重新排序就是一种优化形式，它使得处理更快，因此属术该术语的范畴。许多优化方法在现有技术的编译器优化中都有描述，有些优化方法难以在类似现有技术的“超块”中完成，而在VLIW研究中出现。随后控制被转移至翻译以使增强词态主硬件重新开始执行。
当在运行应用程序中下面遇到某一目标指令序列时，将在翻译缓冲器内寻找主翻译指令并立即执行而无需翻译、优化、或者重新安排。利用下述高级技术，据估计对于每一百万次翻译执行操作而言只有一次需执行释放，而其他均可在翻译缓冲器中找到目标指令的翻译结果(曾经被完整翻译过)。因此在第一次翻译之后，翻译所需的所有步骤(例如译码、提取基本指令，优化基本指令，将其重新安排为主翻译指令并在翻译缓冲器内存储)可以省略。由于为其编写目标指令的处理器在每次执行指令时都必须译码、提取、重新排序和重新安排每条指令，所以这样做大大减少了执行目标指令所需的工作量并提高了改进型微处理器的速度。
在省略所有现有技术处理器执行目标应用程序所需的步骤之后，本发明的微处理器克服了现有技术的问题，使得这类操作可以合理的速度运行。例如改进型微处理器的某些技术被用于上述仿真器以将应用程序移植到其它系统。但是由于在处理翻译指令时，引起调用各种系统意外事件句柄的意外事件发生在主处理器状态与处理同样指令的目标处理器无关的操作时刻，所以一些仿真器无法运行应用程序较长的部分。因此产生这类意外事件时目标处理器的状态是未知的。这样，目标机的正确状态就无法确定；操作必须停止，重新启动，并在意外事件可以处理和继续执行之前确认正确的状态。这使得无法以主机速度运行应用程序。
词态主机硬件包含了解决该问题的多个增强部分。图3、4和5示出了这些增强部分。为了在发生错误时确定寄存器的正确状态，增强硬件提供了一组正式目标寄存器来保存为其设计源应用程序的目标处理器的寄存器状态。目标寄存器可以包含在每个浮点单元、任何整数单元和其它执行单元内。这些正式寄存器连同增加的正常工作寄存器一起被加入词态主机使得包括寄存器重命名的一系列优化深以实现。增强硬件的一个实施例在整数单元内包含64个工作寄存器而在浮点单元内包含32个工作寄存器。实施例还包含一组增强目标寄存器，它们包含所有提供处理器状态的经常变化的目标处理器寄存器；这包括状态控制寄存器和其它控制仿真系统所需的寄存器。
值得注意的是，根据词态主机所用的增强处理硬件类型，翻译指令序列可包含构成从源应用程序来的多条目标指令的基本操作。例如VLIW微处理器可以如图6(a)-(c)所示立即执行多条CISC指令或者RISC指令。无论词态主机类型如何，除了整体目标指令边界以外词态主机硬件的目标寄存器状态是不会改变的；并且随后所有的目标寄存器得到了更新。因此，如果微处理器正在执行目标指令或已经被翻译为可以重新排序和重新安排为主指令的基本操作序列的指令，则当处理器开始执行已翻译的指令序列时，正式目标寄存器在第一条目标指令被寻址时保存由为其设计应用程序的目标处理器寄存器保存的值。但是在词态主机开始执行翻译指令之后，工作寄存器保存由执行到该点的翻译指令基本操作确定的值。因此尽管一些工作寄存器保存的是与正式目标寄存器内相同的值，但是其它工作寄存器内保存的值对于目标处理器毫无意义。在为了采用高级加速技术提供位定目标机更多寄存器的实施例中这尤其如此。一旦开始执行翻译的主指令，工作寄存器中的值是翻译的主指令确定寄存器状态的任何值。如果执行一组翻译的主指令而未产生意外事件，则在这组指令结束时确定的新工作寄存器值就被一起转送至正式目标寄存器(可能包括目标指令指针寄存器)。在处理器的本实施例，这种转移发生于附加的流水线阶段内的主指令执行外部，从而不会降低词态主机的处理速度。
同样，图5所示的门控存储缓冲器在改进型微处理器的硬件中被用来控制数据转移至存储器。门控存储缓冲器包括多个单元，每个可保存存储器存储操作的地址和数据。这些单元可通过任意数量不同的硬件配置实现(例如先进先出缓冲器)；所示实施例利用随机存储器和三个专用工作寄存器实现。三个专用寄存器分别存储指向存储器存储队列头部的指针、指向门的指针和指向存储器存储队列尾部的指针。位于队列头部与门之间的存储器存储内容已经被提交入存储器，而位于队列门与尾部之间的还未提交入存储器。在主指令执行期间产生的存储器存储内容由整数单元将按照词态主机执行主指令的顺序放入存储缓冲器但是在主指令中遇到提交操作以前不允许写入存储器。因此随着翻译指令的执行，存储操作被放入队列。假定这些是第一次存储的内容因而在门控存储缓冲器内没有其它的存储内容，则头部和门指针将指向同一位置。随着每一存储内容的执行，它被放入队列中下一位置并且尾部指针增一指向下一位置(在图中是向上)。这一直持续到执行提交指令为止。这通常发生于完成一组目标指令翻译而未发生意外事件或者出现错误退出条件时。当词态主机正确无误地执行翻译指令时，执行期间生成的存储缓冲器内的存储器存储内容被一起移动通过存储缓冲器的门(提交)并随后写入存储器。在所示实施例中，这是通过将保存尾部指针的寄存器内的值复制到保存门指针的寄存器内完成的。
由此可见，寄存器状态从工作寄存器转送至正式目标寄存器和工作存储器内容转移至正式存储器是一起发生的并且只发生在整个目标指令之间的边界上从而响应明确的提交操作。
这使得微处理器可以从发生于增强词态主机执行指令过程中的目标意外事件中几乎无延迟地恢复过来。如果在运行任何翻译指令或指令期间产生目标意外事件，则由词态主机硬件或软件检测意外事件。为了响应检测到目标意外事件，代码词态化软件可以将正式寄存器内保存的任何值返回工作寄存器并使门控存储缓冲器内未提交的存储器存储内容转储(一种称为“回退”的操作)。图5门控存储缓冲器存储内容的转储可以通过将保存门指针的寄存器内的值复制到保存尾部指针的寄存器内实现。
将目标寄存器的值放入工作寄存器可以使发生意外事件的第一条运行的目标指令的地址放入工作指针寄存器内。从工作寄存器内目标处理器的正式状态开始，发生意外事件时正在运行的目标指令被按照串行顺序重新翻译而不进行重新排序或其它优化。在将每条目标指令重新译码和翻译为新的主指令之后，代表目标指令的翻译后的主指令由词态主机执行并且可能引起意外事件(如果词态主机是VLIW处理器以外的处理器，则主翻译指令的每条基本操作按照顺序执行。如果在主翻译指令执行时没有产生意外事件，则运行下一基本功能)。这一直延续到发生意外事件为止或者单条目标指令被翻译和执行为止。在一个实施例中，如果在执行目标指令翻译时没有产生意外事件，则工作寄存器的状态被转移至目标寄存器并且门控存储缓冲器内的数据被提交从而可以转移至存储器。但是如果在翻译指令运行期间再次发生意外事件，则目标寄存器和存储器的状态未变化而是与发生意外事件时目标计算机内产生的状态一致。因此当产生目标意外事件时，意外事件将由目标操作系统正确处理。
同样，一旦指令系列在翻译时产生意外事件的第一条目标指令执行时未发生意外事件，则目标指令指针指向下一目标指令。这第二条目标指令与第一条指令的处理方式一样，只作译码和重新翻译而不进行优化或重新排序。随着词态主机处理单条目标指令的每条主指令，当目标寄存器和存储器的状态与目标计算机内发生的状态一致时将产生意外事件。因此意外事件得到立即而正确的处理。这些新的翻译指令可以存储在翻译缓冲器内作为目标应用程序内指令序列的正确翻译结果，并在指令再次执行时被调用。
完成与图5门控存储缓冲器同样结果的其它实施例包括这样的方案，它将存储内容直接转移至存储器而与此同时记录足够的数据以在执行翻译结果引起意外事件或者错误(由此需要回退)时恢复目标计算机的状态。在这种情况下，任何在翻译和执行期间发生的存储器存储内容的影响都不得不逆转过来并且恢复翻译开始时存储器的状态；与此同时工作寄存器必须以上述方式接收正式目标寄存器内保存的数据。在实现这项操作的一个实施例中，维持一个分立的目标存储器保存原始的存储器状态，如果发生回退，则该状态被用来代替覆盖的存储器内容。在实现存储器回退的另一实施例中，在每条存储和存储器数据被替换时对它们进行登录并在需要转储时使存储进程逆向进行。
代码词态软件提供了一项新增的操作，它大大加快了被翻译的处理程序的速度。除了简单翻译指令、优化、重新排序、重新安排、高速缓存和执行每条翻译指令从而可以在需要执行该组指令时再次运行以外，翻译器还链接不同的翻译结果以在绝大多数情况下避免返回翻译进程的主循环。图8示出了完成链接进程的代码词态化软件翻译器部分所执行的步骤。对于本领域内的普通技术人员来说，显而易见的是这种链接操作基本上在大多数指令翻译时避免了返回主循环，这节约了开销。
为了阐述方便，运行的目标程序由X86指令组成。当翻译目标指令序列并且重新排序和重新安排基本主指令时，两条基本主指令可能在每条主翻译指令结束处发生。第一条是更新目标处理器的指令指针(或类似的指针)的值；该指令用来将下一目标指令的正确地址放入目标指令指针寄存器。该基本指令之后是一条转移指令，它包含转移的两种可能目标地址。处理转移指令的基本指令可以更新目标处理器的指令指针值，其方式是测试在条件代码寄存器内的条件代码，并随后确定控制转移的条件所指示的两个转移地址的其中一个是否存入翻译缓冲器内。第一次翻译目标指令序列时，主指令的两个转移目标都保存翻译机软件主循环的同一主处理器地址。
当主指令经过翻译，存储在翻译缓冲器并第一次执行时，目标指令指针寄存器(作为其余目标寄存器)内的指令指针得到更新；并且操作转移返回主循环。在主循环内，翻译器软件在目标指令指针寄存器内查找指向下一目标指令的指令指针。随后寻址下一目标指令序列。假定该目标指令序列还未被翻译，因此在翻译缓冲器内未驻留翻译指令，则从存储器提取下一组目标指令，对其译码、翻译、优化、重新排序、重新安排、高速缓存入翻译缓冲器并予以执行。由于第二组目标指令跟随在第一组目标指令之后，所以第一组目标指令的主翻译结束处的基本转移指令就被自动更新替代为第二组目标指令的主翻译指令地址成为控制转移的特定条件转移地址。
如果这样，则第二主翻译主指令循环返回到第一条翻译的主指令，第二翻译指令结束处的转移操作包含主循环地址和第一条翻译指令的X86地址作为转移两种可能的目标。在测试转移状态及决定循环回到第一翻译指令前更新指令指针基本操作并将目标指令指针更新为第一条翻译指令的X86地址。这使得翻译器在翻译缓冲器内查询以确定是否有X86地址。第一条翻译指令的地址被找到，并且它在主机存储器空间内的值被第二条主翻译指令结束处转移中的X86地址上的值替换。随后第二主翻译指令被高速缓存和执行。这使得循环延续下去直到从第一条翻译指令转移到第二条翻译指令的条件失败，并且转移取道返回主循环。当发生这种情况时，第一条翻译主指令返回主循环，从而在翻译缓冲器内搜索目标指令指针指定的下一组目标指令，主指令从高速缓存中提取；或者在翻译缓冲器内找不到，则从存储器内提取该目标指令并进行翻译。当该经过翻译的主指令高速缓存入翻译缓冲器内时，其地址代替了结束循环的转移指令内的主循环地址。
这样，各种翻译主指令被互相串接起来，因此只有在这种串接不存在时才需要历经通过翻译器主循环的长路径。最终，主指令转移指令内主循环参考地址几乎可以完全省略。当达到该条件时，在运行任何主指令之前提取目标指令、译码目标指令、提取构成目标指令的基本指令、优化这些基本操作、重新排序基本操作和重新安排这些基本操作所需的时间可以省去。因此与所有每次执行应用程序指令时必须执行这些步骤的每一步的所有现有技术微处理器相反，利用改进型微处理器在第一条指令执行之后运行任意目标指令组所需的工作量大为减少。当每组翻译的主指令与其它组翻译主指令都链接起来的，工作量可进一步减少。实际上，据估计在应用程序运行期间一百万条翻译指令需要执行的翻译次数不超过一次。
本领域内技术人员将会发现，由于为了避免再次翻译，被翻译的每组指令都被高速缓存，所以微处理器需要大量的翻译缓冲器。针对不同系统编程的应用程序功能而设计的翻译机将根据支持的缓冲存储器不同而有所不同。但是针对运行X86程序设计的微处理器实施例采用2Mb的随机存储器作为翻译缓冲器。
两种新增的硬件增强手段有助于提高本发明微处理器处理应用程序的速度。第一种手段是与每条地址翻译指令一起存储在翻译指令后备缓冲器(TLB)(参见图3)中的异常/正常(A/N)保护位位，在上述缓冲器中首先查询目标指令的物理地址。翻译指令的目标存储器操作可以分为两类，一种是对存储器操作(正常操作)而另一种是对存储器映射I/O设备操作(异常操作)。
作用于存储器的正常存取以正常方式完成。当指令在存储器上操作时，指令的优化和重新排序是有益的并且大大加快了利用本发明微处理器的系统的操作。另一方面，作用于I/O设备的异常存取操作必须按照这些操作编程时的精确顺序进行而不能省略任何步骤，否则对I/O设备有不利的影响。例如某一特定的I/O操作可能是清除I/O寄存器；如果基本操作顺序出错，则操作结果可能会不同于目标指令要求的操作。由于没有区分存储器和存储器映射I/O的装置，所以在翻译指令时需要将所有的存储操作按照是作用于存储器映射I/O指令的保守假设进行处理。这大大限制了优化所能达到的性能。由于现有技术仿真器没有检测被寻址存储器性质预测失效的装置和从这类失效中恢复过来的装置，所以其性能受到限制。
在图11所示的微处理器实施例中，A/N位可以在翻译后备缓冲器内设定以指示是存储器页面还是存储映射I/O的位。翻译后备缓冲器存储用于存储器存取的页面表输入项。每条输入项包括被存取的虚拟地址和可以用以找到数据的物理地址以及其它有关输入项的信息。在本发明中，A/N位属于其它信息部分并且表示物理地址是存储器地址还是存储器映射I/O地址。尽管作用于存储器的操作似乎属于存储器操作，但是实际上该操作的翻译是预测其作用于存储器。在一个实施例中，当代码词态化软件首先执行需要访问存储器或存储器映射I/O设备的指令翻译时，它假定该存取是存储器存取。在另一实施例中，软件可能假定目标指令需要进行I/O存取。假定在此之前未对该地址进行过访问，则在翻译后备缓冲器中将没有相应的输入项；并且在翻译后备缓冲器中的存取失败。这种失败使得软件进行页面表查询并将页面表输入项填入翻译后备缓冲器的存储位置以向虚拟地址提供正确的物理地址翻译结果。此后，软件将物理地址的A/N位输入翻译后备缓冲器内。随后假定访问的是存储器地址，则试图进行再一次的存取。当试图进行存取时，通过将预先假定的存取类型(正常或异常)与TLB页面表输入项内的A/N保护位比较，检验目标存储器的参考地址。当存取类型与A/N保护不一致时，发生意外事件。如果操作实际上作用于存储器，则在翻译期间可以正确应用上述优化、重新排序和重新安排技术。如果与TLB中A/N位的比较表明操作作用于I/O设备，则操作的执行导致意外事件；并且翻译器一次产生一条目标指令的新翻译结果而不进行优化、记录或者重新安排等。同样，如果翻译时错误地将作用于存储器的操作假定为I/O操作，则操作的执行导致意外事件；并且利用优化、重新排序和重新安排技术重新翻译目标指令。这样处理器可以出乎寻常地提高性能。
本领域内的技术人员将会发现，利用A/N位来确定有关存储器访问还是存储器映射I/O设备访问的预测是否失败的技术也可以用来预测存储器映射地址的其它性质。例如可以利用这种正常/异常位来区分不同类型的存储器。本领域内技术人员还可以找到区分存储器性质的其它类似用途。
改进型微处理器预测最多的是翻译内是否发生目标意外事件。这使得与现有技术相比作了明显的优化。首先，目标状态不必在每条目标指令边界上更新而只需在发生在翻译边界的目标指令边界上更新。这省略了在每条目标指令边界上保存目标状态所需的指令。原先无法对安排和去除冗余操作所作的优化现在也变得可行起来。
改进的微处理器适于选择合适的翻译进程。按照上述翻译方法，尽管一组指令是作用于存储器的，但是仍然可以先进行翻译。当优化、重新排序和重新安排主指令执行时，利用翻译后备缓冲器内提供的A/N位状态可能发现是I/O设备的地址。A/N位与表示I/O操作的翻译指令地址进行比较后产生错误意外事件，启动软件初始化转储程序，引起未提交的存储器存储内容转储并将目标寄存器内的值放回到工作寄存器。随后一次对一条目标指令进行翻译而不进行优化、重新排序或者重新安排。这种重新翻译适合于对I/O设备进行主翻译。
同样，存储器操作也可能被错误地翻译为I/O操作。产生的错误可以用来引发正确的重新翻译，对指令进行优化、重新排序和重新安排以提供更快的操作。
现有技术仿真器对称为自修改代码的问题一直比较棘手。即使目标程序应该向包含目标指令的存储器写入内容，这将导致目标指令已有的翻译结果“过时”并不再有效。当这些存储器内容动态发生时需要对它们进行检测。在现有技术中，这种检测需要借助对每条存储使用额外指令完成。这个问题的影响要超出程序自修改本身。任何能够向存储器写入内容的机构，例如第二处理器或DMA设备，也可能引起这个问题。
本发明通过另外的增强词态主机的性能解决这个问题。可以用也存储在翻译后备缓冲器内的翻译位(T位)来表示已存在翻译结果的目标存储器页面。T位可表示特定目标存储器页面包含已被翻译目标指令，如果这些目标指令被覆盖则它们将过时。如果试图向存储器内被保护的页面写入内容，则翻译位的存的将引起意外事件，当代码词态化软件进行处理时将使正确的翻译结果无效或者从翻译缓冲器内去除。T位还可以用来标记其它保护翻译结果不被覆盖的目标页面。
借助图3可以理解这一点，它示出了本发明微处理器总体功能单元的框图。当词态主机执行目标程序时，实际上它运行的是代码词态化软件的翻译器部分，它仅仅包括有效运行在词态主机上的初始未翻译主指令。图中右边是存储器，它被划分为包含翻译器和翻译缓冲器的主机部分和包含目标指令和数据(包括目标操作操作系统)的目标部分。词态主机硬件开始执行翻译器时从存储器内提取主指令并将其放入指令高速缓存内。翻译器指令产生对存储在存储器目标部分内的第一条目标指令的提取指令。目标提取指令使整数单元在正式目标指令指针寄存器内查找目标指令的开始地址。随后将开始地址放入存储器管理单元的翻译后备缓冲器内。存储器管理单元包括页面查找硬件并提供TLB的存储器映射手段。假定TLB被正确映射从而保存了目标存储器正确页面的查找数据，则目标指令指针值被翻译为目标指令的物理地址。此时，对表示目标指令是否完成翻译的位(T位)状态进行检测；但是访问是读操作，并且不会发生T位意外事件。还检测了表示是对存储器还是存储器映射I/O访问的A/N位的状态。假定后面提及的位表示存储位置，则由于不存在翻译结果，所以在目标存储器内访问目标指令。目标指令和后续目标指令作为数据被转移至词态主机计算单元并在指令高速缓存内存储的翻译器指令的控制下进行翻译。翻译器指令采用重新排序、优化和重新安排技术，就好象处理作用于存储器的目标指令一样。随后将包含主指令序列的最终翻译结果存储在主存储器的翻译缓冲器内。翻译结果经门控存储缓冲器被直接转送至主存储器的翻译缓冲器内。一旦将翻译结果存储在主存储器内之后，翻译器转入随后执行的翻译。所执行的操作(以及后续操作)确定翻译是否对意外事件和存储器作出了正确的假设。在执行翻译之前，对包含已翻译目标指令的目标页面的T位进行设定。该指示提醒指令已经翻译；并且如果试图向目标地址写入内容，则将导致意外事件，可能使得翻译结果无效或者被除去。
如果试图向用T位标记的目标页面写入内容，则产生意外事件并中止写入。在意外事件的响应确认对写入目标存储器地址的指令翻译是无效的或者受到保护的，直到它们被适当更新之后，写入操作才可以继续。由于翻译不起作用，所以有些写入操作实际上不需要做。其它的写入操作则需要，做一条或更多与寻址的目标存储器(相关的翻译被适当标记或者去除)。图11示出了翻译后备缓冲器的实施例，包含保存T位指示的每条输入项的存储位置。
新增的加强词态主机性能的硬件电路可以使正常存储在存储器内但经常用于操作执行的数据在执行单元寄存器内被复制(或者“别名”)以便节省从存储器内提取存储器内的时间。为了在实施例中完成别名操作，词态主机被设计一个“装入和保护”命令为响应将存储器数据复制到图10所示执行单元110的工作寄存器111内并将存储器地址放入该单元的寄存器112内。与地址寄存器相连的是比较器113。比较器接收加载地址并在翻译期间存入指向存储器的门控存储缓冲器。如果加载或存储的存储器地址与寄存器112(或根据实施方案不同是其他的寄存器)进行比较，则产生意外事件。代码词态软件通过确保存储器地址与寄存器保存相同正确的数据响应该意外事件。在实施例中，为此重新翻译并不用执行单元寄存器内的“别名”数据重新执行。解决这个问题的其它可行方法是用最近的存储器数据更新执行单元寄存器或者用最近的加载数据更新存储器。
本领域内的技术人员将会发现，微处理器可以通过电路形式与典型的计算机单元连接从而构成诸如图9所示的计算机。显而易见，当微处理器用于现代X86计算机时，它可以通过处理器总线与存储器和总线控制电路连接。存储器和总线控制电路提供了对主存储器的访问，也提供了对与微处理器一起使用的高速缓存的访问。存储器和总线控制线路还提供了对诸如PCI或其它局部总线的访问，通过这些总线对I/O设备进行访问。特定的计算机系统取决于由本发明微处理器所替代的典型微处理器一起使用的电路。
为了描述处理器的操作和加快执行速度的方法，这里的实例是将少量X86目标代码翻译为主基本指令。实例涉及了将X86目标指令翻译为词态主机指令的过程，包括本发明微处理器所作的优化、重新排序和重新安排各种步骤。通过以下描述的过程，本领域内技术人员将会理解利用目标处理器执行源指令所需的操作与主处理器上执行翻译所需操作之间的差别。
用C语言源代码编写的源指令描述了一个非常简单的循环操作。当每次循环后都减一的变量“n”大于“0”时，数值“c”存储在指针“*s”表示的地址内，每次循环之后该指针都增一。
<pre listing-type="program-listing"><![CDATA[Oniginal C code while((n--)＞0) { *s++=c }====================================================================win32X86instructions produced by a compiler compiling this C code.mov％ecx,[％ebp+0×c] // load c from memory address into the ％ecxmov％eax,[％ebp+0×6］ // lcad s from memory address intc the ％eaxmov[％eax],％ecx// store c into memory address s held in ％eaxadd％eax,#4 // incremenc s by 4.mov(％ebp+0×8],％eax // store(s+4)back into memorymov％eax,[％ebp+0×10] // load n from memory address into the ％eaxlea％ecx,[％eax-1] // decrement n and store the result in ％ecxmov[％ebp+0×10],％ecx // store (n-1) into memoryand％eax,％eax // test n to set the condition codesjg .-0x1b // branch to the top of this section if“n＞0”]]></pre>在实例的第一部分，执行用C语言语句定义的操作的每条X86汇编语言指令用汇编语言操作助记符列示，后面跟着涉及特定基本操作的参数。每条指令的注释对操作作了解释。虽然所示的执行顺序可以由目标处理器改变，但是每次执行目标C语言指令的循环时每条汇编语言指令都必须执行。因此，如果循环执行100次，则所示的每条指令也必须执行100次。
<pre listing-type="program-listing"><![CDATA[Shows each X86 Instruction shown above followed by the host instructions necessary to Implement theX86 Instruction. mov ％ecx,[％ebp+0×c]// load c from memory address into ecx add RO,Rebp,0×c ;form the memory address and put it in RO ld Recx,[Ro] ;load c from memory address in RO into Recx mov ％eax,[％ebp+0×8]// load s from memory address into ％eax add R2,Rebp,0×8 ;form the memory address and put it in R2 ld Reax,[R2] ;load s from memory address in R2 into Recx mov [％eax],％ecx // store c into memory address s held in ％eax st [Reax],Recx ;store c into memory address s held in Reaxadd ％eax,#4// increment s by 4add Reax,Reax.4 ;increment s by 4mov [％ebp+0×8],％eax // store(s+4) back into memoryadd Rs,Rebp,0×8;form the memory address and put it in R5st [R5],Reax ;store(s+4) back into memorymov ％eax,[％ebp+0×10] // load n from memory address into ％eaxadd R7,Rebp,0×10 ;form the memory address and put it in R7ld Reax,[R7] ;load n from memory address into the Reaxlea ％ecx,[％eax-1] // decrement n and store the result in ％ecxsub Recx,Reax,1 ;decrement n and store the result in Recxmov [％ebp+0×10],%ecx // store(n-1)into memoryadd R9,Rebp,0×10 ;form the memory address and put it in R9st [Rg],Recx ;store(n-1)into memoryand ％eax,％eax // test n to set the condition codesandcc Rll,Reax,Reax ;test n to set the condition codesjg .-0×1b // branch to the top of this section if “n＞0”jg mainloop,mainloop ;jump to the main loopHost Instruction key ld=load add=ADD st=store sub=subtrtactjg=jump if condition codes indicate greater andcc=and set the condition codes]]></pre>
下一实例描述了执行C语言指令的同一目标基本指令。但是在每条基本目标指令之后列出了在微处理器特定实施例中完成同一操作所需的基本主指令，其中词态主机为针对上述方式设计的VLIW处理器。值得注意的是，正式目标寄存器屏蔽的主寄存器用X86寄存器名的前面加“R”表示，因此例如Reax表示与EAX正式目标寄存器相关的工作寄存器。
<pre listing-type="program-listing"><![CDATA[Adds host instructions necessa to performX86 address computation and upper and lowersegment limit checks.mov ％ecx,[％ebp+0×c] // 1oad cadd R0,Rebp,0×c ;form logical address into ROchkl R0,Rss_limit ;check the logical address against segment lowerlimitchku R0,R_FFFFFFFF;check the logical address against segment upperlimitadd R1,R0,Rss_base ;add the segment base to form the linearaddressldRecx,[R1];load c from memory address in R1 into Recxmov ％eax,[％ebp+0×8] //load sadd R2,Rebp,0×8 ;form logical address into ROchkl R2,Rss_limit ;Check the logical address against segment lowerlimitchku R2,R_FFFFFFFF;Check the logical address against segment upperlimitadd R3,R2,Rss_base ;add the segment base to form the linearaddressldReax,[R3];load s from memory address in R3 into Ramov [％eax],％ecx // store c into [s]chku Reax,Rds_limit ; Check the logical address against segment upperlimitadd R4,Reax,Rds_base ;add the secgment base to form the linearaddressst[R4],Recx;store c into memory address sadd ％eax,#4 // increment s by 4addcc Reax,Reax,4 ;increment s by 4mov [％ebp+0×8]，％eax// store(s+4)to memory add R5,Rebp,0×8 ;form logical address into R5 Chkl R5,Rss_limit ;Check the logical address against segment lower limit Chku R5,R_FFFFFFFF ;Check the logical address against segment upper limit add R6,R5,Rss_hase ;add the segment base to form the linear address st [R6],Reax ;store(s+4)to memory address in R6mov ％eax,[％ebp+0×l0]// load nadd R7,Rebp,0×l0 ;form logical address into R7chkl R7,Rss_limit;Check the logical address against segment lowerlimitchku R7,R_FFFFFFFF ;Check the logical address against segment upperlimitadd R8,R7,Rss_base ;add the segment base to form the linearaddressldReax,[R8] ;load n from memory address in R8 into Reaxlea ％ecx,[％eax-1] // decrement nsub Recx,Reax，l;decrement nmov [％ebp+0×10],％ecx // store(n-1)add R9,Rebp,0×l0 ;form logical address into R9chkl R9,Rss_limit;Check the logical address against segment lowerlimitchku R9,R_FFFFFFFF ;Check the logical address against segment upperlimitadd R10,R9,Rss_base ;add the segment base to form the linearaddressst[R10],Recx ;store n-1 in Recx into memory using addressin R10and ％eax,％eax // test n to set the condition codesandcc R11,Reax,Reax ;test n to set the condition codesjg.-0×1b // branch to the top of this section if “n＞0”jgmainloop,mainloop ;jump to the main loopHost Instruction key Chkl+check lower limit Chku=check upper limit]]></pre>
下一实例表示每条基本目标指令的主基本指令加法，代码词态化软件可以利用其产生目标操作所需的地址。值得注意的是，主地址生成指令只是在采用代码词态化软件而非地址生成硬件来生成地址的微处理器实施例中才需要。在诸如X86微处理器之类的目标处理器中，地址是利用地址生成硬件生成的。在这里的实施例中，无论何时产生地址，都完成了计算；并且还加入主基本指令以检查地址值从而确定计算的地址是否在合适的X86段边界内。
<pre listing-type="program-listing"><![CDATA[Adds instructions to maintain the targetX86 instruction pointer “eip”andthe commit instructions that use the special morph host hardware to updateX86 state.mov ％ecx,[％ebp+0×c] // lead cadd R0,Rebp,0×cchkl R0,Rss_limitchku R0,R_FFFFFFFFadd R1,RO,Rss_baseldRecx,[R1]add Reip,Reip,3 ;add ×86 instruction length to eip inReipcommit ;commits working state to official statemov ％eax,[％ebp+0×8] // load sadd R2,Rebp,0×8chk1 R2,Rss_limitchku R2,R_FFFFFFFFadd R3,R2,Rss_baseldReax,[R3]add Reip,Reip,3 ;add X86 instruction length to eip inReipcommit ;commits working state to official statemov [％eax],％ecx // storec into [s]Chku Reax,Rds_limitadd R4,Reax,Rds_basest[R4],Recxadd Reip,Reip,2 ;add×86 instruction length to eip inReipcommit ;commits working state to official stateadd ％eax，#4 // increment s by 4addcc Reax,Reax,4add Reip,Reip,5 ;add×86 instruction length to eip inReipcommit ;commits working state to official statemov [％ebp+0×8],％eax// store(s+4)add R5,Rebp,0×8chkl R5,Rss_limitchku R5,R_FFFFFFFFadd R6,R5,Rss_basest[R6],Reaxadd Reip,Reip，3 ;add X86 instruction length to eip inReipcommit ;commits working state to official statemov ％eax,[％ebp+0×10]// load nadd R7,Rebp,0×l0chkl R7,Rss_limitchku R7,R_FFFFFFFFadd R8,R7,Rss_baseldReax,[R8]add Reip,Reip,3;add ×X86 instruction length to eip inReipcommit ;commits working state to official statelea ％ecx,[％eax-1]// decrement nsub Recx,Reax,1add Reip,Reip,3;add X86 instruction length to eip inReidcommit;commits working state to official statemov [％ebp+0x10],％oecx // store(n-1)add R9,Rebp,0×10chkl R9,Rss_limitchku R9,R_FFFFFFFFadd R10,R9,Rss_basest[R10],Recxadd Reip,Reip,3 add X86 instruction length to eip inReipcommit ;commits working state to official stateand ％eax,％eax // test nandcc Rll,Reax,Reaxadd Reip,Reip,3commit ;commits working state to official statejg.-0×1b // branch “n＞0”add Rseq,Reip,Length(jg)ldc Rtarg,EIP(target)selcc Reip,Rseq,Rtargcommit ;commits working state to official statejgmainloop,mainloopHost Instruction key commit=copy the contents of the working registers to the official target registers and send working stores to memory]]></pre>本实例示出了每组基本主指令的两步相加，在执行了完成每条基本指令所需的主指令后更新正式目标寄存器并将门控存储缓冲器内未提交的值提交入存储器。显而易见，在每种情况下，目标指令的长度与工作指令指针寄存器(Reip)内的值相加。随后执行提交指令。在实施例中，提交指令对屏蔽在相关正式目标寄存器的工作寄存器的当前值进行复制并将指定门控存储缓冲器位置的指针值从紧靠未提交存储数据之前移动至紧靠这些存储数据之后从而将它们放入存储器。
显而易见的是上面最后示出的指令清单都是构成源目标汇编语言指令的主指令翻译所需的指令。如果翻译操作在该处停止，则基本主指令的数量将远远大于目标指令数量(大约是6倍)，并且执行时间将超过目标处理器。但是此时尚未对指令进行过重新排序、优化和重新安排。
如果指令得到了运行但只是一次，则完成指令进一步重新排序和其它优化所需的时间可能超过此时执行翻译的时间。如果这样，微处理器实施例将在此处停止翻译，存储翻译结果，随后执行翻译指令以确定是否发生意外事件或错误。在本实施例中，重新排序其它优化步骤仅仅发生在经确定某一翻译操作将进行多次或者需要优化时。例如通过在每条翻译指令内放入对翻译执行进行计数并在计数值达到某一数值时产生意外事件(或转移)的主指令来实现。意外事件(或转移)将操作转移至代码词态化软件，由其进行下述部分或所有优化以及任何适于该翻译操作的其它优化。第二种确定翻译指令执行次数和是否需要优化的方法是以一定的频度或者根据一些统计依据中断翻译指令的执行，并优化该时刻运行的任何翻译指令。这最终使得最经常运行的指令得到了优化。另一种方案是对每一条特定类型的主指令进行优化，例如生成循环的主指令或者运行次数可能最多的主指令。
<pre listing-type="program-listing"><![CDATA[OptImizatlOn=====================================================================================Assumes 32 bit flaaddress space which allows the elimination of segment base additions andsome limit checks．Win32 Uses Flat 32b segmenationRecoRD AssumptionsRss_base==ORss_limit=ORds_base==DRds_limit==FFFFFFFFSS and DS prolection checkmov％ecx,[％ebp+0×c]//load cadd R0,Rebp,O×cchku R0,R_PFFFFFFFld Recx,[R0]add Reip,Reip,3commitmov ％eax,[％ebp+0×8]//load sadd R2,Rebp,0×8chku R2,R_FFFFFFFFld Reax.[R2]add Reip,Reip,3commitmov [％eax],％ecx//store c into [s]chku Reax,R_FFFFFFFFsT [Reax],Recxadd Reip,Reip,2commitadd ％eax,#4 //increment 5 by 4addcc Reax,Reax,4add Reip,Reip,5commitmov [％ebp+0×8]，％eax// store(s-4)add R5,Rebp,0×8chku R5,R_FFFFFFFFst[R5],Reaxadd Reip,Reip,3commitmov ％eax,[％ebp+0×10]// load nadd R7,Rebp,0×10chku R7,R_FFFFFFFFldReax,[R7]add Reip,Reip,3commitlea ％ecx,[％eax-1] // decrement nsub Recx,Reax,1add Reip,Reip,3cmmitmov [％ebp+0×10],％ecx// store(n-1)add R9,Rebp,0×10chku R9,R_FFFFFFFFst[R9],Recxadd Reip,Reip,3commitand ％eax,％eax// test nandcc Rll,Reax,Reaxadd Reip,Reip,3commitjg.-0×1b // branch “n＞0”add Rseq,Reip,Length(jg)ldc Rtarg,EIp(target)selcc Reip,Rseq,Rtargcommitjgmainlcop,mainloop]]></pre>本实例示出了可以利用改进型微处理器实现的优化步骤的第一步。在优化阶段，就象代码词态化软件的许多其它操作一样，假定是有优化结果的。特定的优化操作假定作为为X86系列处理器普通存储器模型编写的目标应用程序作为32位程序将继续保持原样。将会注意到是，这种假设只针对X86系列而对其它被仿真的处理器系列并非必要。
如果假设成立，则在X86应用程序中所有的段都被映射至相同的地址空间。这使得可以减少X86分段处理所需的基本主指令。显而易见，段值开始时被设定为零。随后，数据基点也被设定为零，并且上限被设定为最大可用存储空间。随后在执行目标基本指令的每组基本主指令中，都省略了分段所需的对段基点值的检查和段基点地址的计算。这减少了用于需要寻址功能的每条目标基本指令的两条主基本指令执行循环的次数。此时仍然需要主指令检查存储空间上限。
值得注意的是，这种优化需要对应用程序是否采用32位普通存储器模型作出预测。如果不是这样的情况，则由于主循环要实现的目的地址的控制转移并检查出源地址假设与目的地址假设不匹配，所以将会发现错误。随后将进行新的翻译操作。这种技术非常常用并且被应用于各种分段操作和其它不经常变化的“模式化”情况，诸如调试、系统管理模式或“实”模式之类的“模式”。
<pre listing-type="program-listing"><![CDATA[mov ％ecx,[％ebp+0×c]// load cadd R0,Rebp,0×cld Recx,[RO]add Reip,Reip,3commitmov ％eax,[％ebp+0×8] // load sadd R2,Rebp,0×8ld Reax,[R2]add Reip,Reip,3commitmov [eax],％ecx // store c into [s]st [Reax],Recxadd Reip,Reip，2commitadd ％eax,#4 // increment s by 4addcc Reax,Reax,4add Reip,Reip,5commitmov [％ebp+0×8],％eax // store(s-4)add R5,Rebp,0×8st [R5],Reaxadd Reip,Reip,3commitmov ％eax,[％ebp+0×10] // load nadd R7,Rebp,0×10ldReax,[R7]add Reip,Reip,3commitlea ％ecx,[％eax-1] // decrement nsub Recx,Reax,1add Reip,Reip,3commitmov [％ebp+0×10],％ecx// store(n-1)add R9,Rebp,0×10st[R9],RecxaddReip,Reip,3commitand ％eax,％eax // test nandcc R11,Reax,Reaxadd Reip,Reip,3commitjg.-0×1b // branch “n＞0”add Rseq,Reip,Length(jg)ldc Rtarg,EIP(target)selcc Reip,Rseq,Rtargcommitjgmainloop,mainloopHost Instruction key selcc=Select one of the source registers and copy its contents to the destination register based on the condition codes.]]></pre>上述实例示出了优化步骤的下一阶段，其中的预测翻译操作避免了存储上限边界的检查，这只对于穿越位于存储器地址空间顶部的存储器参考位置的未定位页面才需要。这种假设的失效由硬件或软件定位工具检查。这减少了对需要寻址的每条目标基本指令用另一主基本指令翻译的量。这种优化需要以前所作的假定，应用程序使用32位普通存储器模型并且预测到指令得到了定位。如果上述假设和预测都得不到满足，则当执行翻译指令时将会失效；并且需要重新翻译。
<pre listing-type="program-listing"><![CDATA[Detect and eliminale redundant address calculations. The example shows the code aftereliminating the redundanl operations.mov ％ecx,[％ebp+0×c] // load cadd R0,Rebp,0×cldRecx,[R0]add Reip,Reip,3commicmov ％eax, [％ebp+0×8] // load sadd R2,Rebp,0×8ldReax,[R2]add Reip,Reip,3commitmov [％eax],％ecx // store c into [s]st [Reax],Recxadd Reip,Reip,2commitadd ％eax,#4// increment s by 4addcc Reax,Reax,4add Reip,Reip,5commitmov [％ebp+0×8],％eax // store(s+4)st(R2),Reaxadd Reip,Reip,3commiemov ％eax,[％ebp+0×10] // load nadd R7,Rebp,0×101dReax,[R7]add Reip,Reip,3commitlea ％ecx,[％eax-1] // decrement nsub Recx,Reax,1adt Reip,Reip,3commitmov [％ebp+0x10],％ecx // store(n-1)st[R7],Recxadd Relp,Reip,3commitand ％eax,％eax // tes nandcc R11,Reax,Reaxadd Reip,Reip,3commitjg.-0×1b // branch “n＞0”add Rseq,Reip，Length(jg)ldc Rtarg,EIP(target)selcc Reip,Rseq,Rtargcommitjgmainloop,mainloop]]></pre>本实例示出了下一步优化，其中省略了共用的主指令表达方式。具体而言，在翻译第二条目标基本指令时，工作寄存器Rebp(表示X86处理器堆栈基点寄存器的工作寄存器)内的值与偏移值0×8相加并放入主工作寄存器R2。将会注意到的是，除了将加法结果放入工作寄存器R5以外，在前面的实例中，翻译目标基本指令5时进行的是同一操作。因此当主基本指令5执行期间工作寄存器R5内放入的值已经存在于工作寄存器R2。这样在翻译目标基本指令5时可以省略主加法指令；将工作寄存器R2的值复制到工作寄存器R5内。同样，由于在翻译目标基本指令6时已经完成了将工作寄存器Rebp的值与偏移值0×10相加的步骤并且结果驻留在寄存器R7内，所以在翻译目标基本指令8时可以省略该步骤。值得注意的是这种优化不依赖于预测，因此不会失效或者需要重新翻译。
<pre listing-type="program-listing"><![CDATA[Assume that target exceptions will not occur within the translation so delay updating eip andtarget state.mov ％ecx,[％ebp+0×c] // load cadd R0,Rebp,0×cldRecx,[R0]mov ％eax,[％ebp+0×8] // load sadd R2,Rebp,0×8ldReax,[R2]mov [％eax],％ecx // sTtore c into [S]st[Reax],Recxadd ％eax,#4 // increment s by 4add Reax,Reax,4mov [％ebp+0×8],％eax// store(s+4)st[R2],Reaxmov ％eax,[％ebp+0×10] // load nadd R7,Rebp,0×10ldReax,[R7]lea ％ecx,[％eax-1] // decrement nsub Recx,Reax,1mov [％ebp+0×10],％ecx // store(n-1)st[R7],Recxand％eax,％eax // test nandcc R11,Reax,Reaxjg .-0×1b // branch “n＞0”]]></pre>上述实例示出了一种优化步骤，它预测构成整个翻译操作的基本目标指令的翻译能够不发生意外事件就完成。如果符合预测情况，则无需在执行一条目标基本指令的每一主基本指令序列结束时更新正式目标寄存器或者提交存储缓冲器内的未动用存储结果。如果预测为真，则只需在目标基本指令序列结束时更新正式目标寄存器并且存储内容只需被提交一次。这可以省略两条执行每一基本目标指令的基本主指令。它们被一条更新正式目标寄存器并将未动用存储内容提交入存储器的主基本指令代替。
显而易见的是，其它的预测操作也极有可能是正确的预测。如果预测保持为真值，那么该步骤与现有仿真技术比就有极大的优势。它使所有执行目标基本指令的基本主指令归类为一个序列从而可以对所有主基本指令逐条优化。这有利于在得益于超长指令字技术的词态主机上并行运行大量的操作。由于有更多的优化选择，所以可以采用其它大量的优化。但是如果预测情况失真并且在执行循环时发生意外事件，则由于直到实际执行主指令序列后才发生提交操作，所以正式目标寄存器和存储器保存的是目标基本指令序列开始时的正式目标状态。从意外事件恢复所需的操作是转储未动用的存储内容，使正式寄存器返回工作寄存器并在序列开始时重新翻译目标基本指令。这种重新翻译一次翻译一条目标指令，并且在代表每条目标基本指令的主序列翻译之后才更新正式状态。随后执行翻译。当该重新翻译过程中出现意外事件时，立即使用正式目标寄存器和存储器的正确目标状态来执行意外事件。
<pre listing-type="program-listing"><![CDATA[In summaryaddR0,Rebp,O×cld Reox,[R0]addR2,Rebp,0×8ld Reax,[R2]st [Reax],RecxaddReax,Reax,4s[R2],ReaxaddR7,Rebp,0×10ld Reax,[R7] //Live outsubRecx,Reax,1//Live outst [R7],Recxandcc R11,Reax,ReaxaddRseq,Reip,Length(block)ldcRtarg,EIP(target)selcc Reip,Rseq,Rtargcommitjg mainloop，mainloopThe camment“Live out”refers to the need to actually maincain Reax and Recxcorrectly priOr to che commit, Otherwise further optimization might bepossible．===========================================================]]></pre>上述总结示出了优化过程中处于该位置时保留的主基本指令序列。虽然本实例示出了目标指令指针(EIP)串列的维护，但是也可以使翻译时转移的指针EIP保持不一致，这将省去实例中本步骤和后续步骤中更新序列的指针EIP。
<pre listing-type="program-listing"><![CDATA[Renaming to reduce register resource dependencies. This will allow subsequent scheduling to bemore effective. From this point on， the original target X86 code is omitted as the relationshipbetween individual target X86 instructions and host instructions becomes increasingly blurred.add R0,Rebp,OxcldR1， [R0]add R2，Rebp，0×8ldR3，[R2]st[R3]，R2add R4，R3，4St[R2]，R4add R7，Rebp，0×10ldReax，[R7] // Live outsub Recx，Reax，1 // Live outst[R7]，Recxandcc R11，Reax，Reaxadd Rseq，Reip， Length(block)ldc Rtarg，EIP(target)selcc Reip，Rseq， Rtargcommitjgmainloop，mainlocp]]></pre>本实例示出了通常称为寄存器更名的下一优化步骤，其中需要使用在主基本指令系列中用于多个操作的工作寄存器的操作改为采用不同的未使用工作寄存器以防止两条主指令要求使用同一硬件。因此，例如在上述两例中的第二条主基本指令采用代表正式目标寄存器ECX的工作寄存器Recx。第十条主基本指令也使用工作寄存器Recx。通过改变第二主基本指令中的操作从而使R0内地址所指向的值存储在工作寄存器R1而不是寄存器Recx，两条主指令就不会使用同一寄存器。同样，第四、第五和第六条主基本指令在前面实例中都使用工作寄存器Reax；通过使第四主基本指令使用前面未使用的工作寄存器R3而第六主基本指令使用前面未使用的工作寄存器R4，避免了它们使用同一硬件。
<pre listing-type="program-listing"><![CDATA[Aher the scheduling process which organizes the primitive host operations as multipleoperations that can execute in the parallel on the host VLIW hardware. Each line shows theparallel operations that the VLIW machine executes, and the “&” indicates the parallelism. add R2,Rebp，0×8 & add R0,Rebp,0×c nop & add R7,Rebp, 0×20 ldR3,[R2]& add Rseq, Reip,Length(blqck) ldRl,[R0]& add R4,R3,4 st[R3],R1& ldc Rtarg,EIP(arget) ldReax,[R7] & hop st[R2]，R4 & sub Recx,Reax, 1 st[R7],Recx & andcc Rll,Reax,Reax selcc Reip, Rseq, Rtarg & jg mainloop,mainloop & commitHost Instruction key nop=no operation]]></pre>
上述实例示出了在词态主机上执行的主基本指令的安排。在该实例中，假定词态主机为VLIW处理器，除了用于协调词态化软件的硬件增强部分以外，词态主机还包括其它处理单元中的两个算术和逻辑(ALU)单元。第一行表示两个单独的相加指令，它们尽管安排在词态主机上一起运行。显而易见，在前述实例中它们是第三和第八条基本主指令。第二行包括NOP指令(无操作但是进入下一指令)和另一加法操作。NOP指令表示即使在经过某些安排优化之后也不一定是两条指令放在一起运行。在任何情况下，该实例示出了此时只剩下9组基本主指令来执行原先10条目标指令。
<pre listing-type="program-listing"><![CDATA[Resolve host branch targets and chain stored translationsadd R2,Rebp, 0×8& add R0,Rebp, 0×cnop& add R7,Rebp,0×l01dR3，[R2] & add Rseq,Reip,Length(block)ldR1,[R0] & add R4,R3,4st[R3],R1 & ldc Rtarg,EIP(target)ldReax,[R7]& nopst[R2],R4 & sub Recx,Reax,1st[R7],Recx& andcc R11,Reax,Reaxselcc Reip,Rseq, Rtarg & jg Sequential,Target & connit]]></pre>本实例除了指令现在被存储于翻译缓冲器内并且执行一次以上(由于最后的跳转(jg)指令现在指向将另一翻译指令序列串接起来的跳转地址)以外基本上是同一组主基本指令。串接过程使指令序列跳出了翻译器主循环从而完成了序列的翻译。
<pre listing-type="program-listing"><![CDATA[Advanced Optimizations,Backward Code MotionThis and subsequent examples start with the code prior to scheduling. Thisoptimization first depends on detecting that the code is a loop.Theninvariant operations can be moved out of the loop body and executed oncebefore entering the loop body.entry add RO,Rebp,0×c add R2,Rebp,0×8 add R7,Rebp,0×10 add Rseq,Reip,Length(block) ldc Rtarg,EIP(target) Loop ldR1,[R0] ldR3,[R2] St[R3],R1 add R4,R3,4 st[R2],R4 ldReax,[R7] sub Recx,Reax,1s2[R7],Recxandcc R11,Reax,Reaxselcc Reip,Rseq,Rtargcommitjg mainloop,Loop]]></pre>上述实例示出了通常只与大量重复的序列一起使用的高级优化步骤。该进程首先检测构成循环的翻译，并检查单条基本主指令以确定循环体内哪条指令产生不变结果。这些指令从循环内去除并且只执行一次，将值被放入寄存器内；从此，存储在寄存器内的值被重复使用而不是重新运行指令。
<pre listing-type="program-listing"><![CDATA[Scheduletheloop body after backwerd code motion. For example purposes， only thecode in the loop body is shown scheduledEntryadd R0,Rebp,0×cadd R2,Rebp,0×8add R7,Rebp,0×20add Rseq,Reip,Length(blcck)ldc Rtarg.EIP(target)LoopldR3,[R2]& nopldR1,[R0]& add R4,R3,4st[R3],R1& nopldReax,[R7] & nopst[R2],R4& sub Recx,Reax,1st[R7],Recx & andcc R11,Reax,Reaxselcc Reip,Rseq, Rtarg & jg Sequencial,Loop & commitHost Instruction keyldc=load a 32-bit constant]]></pre>当这些不重复的指令从循环中去除并且对序列进行安排之后，它们与上述实例中的指令相同。由此可见，在循环第一次迭代期间完成初始化指令但是只执行一次，此后在循环期间只执行所示7个时钟间隔内剩余的主基本指令。这样执行时间从10条指令间隔缩短为7个指令间隔就能执行基本目标指令。
显而易见，从循环中去除的步骤是地址生成步骤。这样在改进型微处理器内只需在循环开始时生成一次地址；即，地址只需生成一次。另一方面，X86目标处理器的地址生成硬件必须在每次执行循环时生成地址。如果循环执行100次，则改进型微处理器只生成一次地址而目标处理器要生成100次的地址。
<pre listing-type="program-listing"><![CDATA[After Backward Code Motion:Target: add R0,Rebp,0×c add R2,Rebp,0×8 add R7,Rebp,0×10 add Rseq,Reip,Length(block) ldc Rtars,EIP(target)Loop: ldR1,[R0] ldR3,[R2] st[R3],R1 add R4,R3,4 St[R2],R4 ldReax,[R7] //Live out sub Recx,Rsax,1 //Live outat [R7],Recxandcc R11,Reax,Reaxselcc Reip, Rseq, Rtargcommitjg mainloop,Loop======================================================================= Register Ailocation: This shows the use of register alias detaction hardware of the morph host that allows variables to be safely moved from memory into registers.The starting point is the code after "backward code motion",This shows the optimization that can eliminate loads. First the loads are performed.The address is protected by the alias hardware,such that should a store to the address occur, an "alias" exception is raised.The loads in the loop body are then replaced with copies.After the main body of the loop.the alias hardware is treed. Entry: addR0,Rebp, 0×c addR2,Rebp, 0×8 add R7,Rebp,0×10 add Rseq,Reip,Length(block) ldc Rtarg,EIP(target) ldRc, [R0] ;First do the load of the variable from memory prot [R0],Aliasl;Then protect the memory location from stores ldRs,[R2] prot [R2],Alias2 ldRn,[R7] prot [R7],Alias3Loop: copy R1,Rc copy R3,Rs st [R3],R1 add R4,Rs,4 copy Rs,R4 St [R2],Rs,NoAliasCheck copy Reax,Rn //Live out sub Recx. Reax, 1//Live out copy Rn. Recx st [R7],Rn,ncAliasCheckandcc R11,Reax,Reaxselcc Reip,Rseq,RcargcommitjgEpilog,Loop EpilcgFA Alias1 Free the alias detection hardwareFA Alias2 Free the alias detection hardwareFA Alias3 Free the alias detection hardwarej SequentialHost Instruction key protect=protect address from loads FA = free alias copy=copyj = jump]]></pre>本实例示出由本发明微处理器实现的更为高级的优化步骤。参见本实例前的第二个实例就会注意到堆栈内涉及地址计算的前3条相加指令。这些地址在主操作序列执行期间不会变化。因此这些地址上存储的值可以从存储器内查找出来并载入寄存器以供立即使用。显而易见，在主基本指令6、8和10中都是这样做的。在指令7、9和11中，每个存储器地址被特殊的主别名硬件加上保护标记并且寄存器被表示为这些存储器地址的别名，所以如果试图改变数据就会引发意外事件。此时，每条涉及从堆栈存储器地址移动数据的加载操作都变为简单的寄存器之间的复制操作，这比从存储器地址加载数据要快许多。值得注意的是，一旦循环执行到n=0，则必须去除每个存储器地址上的保护从而可以使用别名寄存器。
<pre listing-type="program-listing"><![CDATA[Copy Propagation After using the alias hardware to turn loads within the loop body into copies,copy propagation allows the elimination of some copies. Entryadd R0,Rebp,0×cadd R2,Rebp,0×8add R7,Rebp,0×10add Rseq,reip,Length(block)ldc Rtarg,EIP(target)ldRc,[Rc]prot [R0],AliaslldRs,[R2]prot [R2],Alias2ld Recx,[R7] prot [R7],Alias3Loop st [Rs],Rc addRsRs,4 st [R2],Rs,NoAliasCheck copy Reax,Recx //Live out subRecx,Reax,1 //Live out st [R7],Recx,NoAliasCheck andcc R11,Reax,Reax selcc Reip,RseqRcarg commit jg Epilog,LoopEpilog FAAliasl FAAlias2 FAAlias3 j Sequential]]></pre>本实例示出了下一优化步骤，其中大多数代替上一实例中优化的加载指令的复制指令并非必要并且可以省略。即，如果进行寄存器之间的复制，则在复制数据的寄存器的操作前数据已经存在。如果是这样，可以在第一寄存器内访问数据而不是在复制数据的寄存器内，因此可以省略复制操作。显而易见，这省略了上一实例循环中所示的第一、第二、第五和第九基本主指令。此外，其它主基本指令中所用的寄存器也可以改为反映正确的寄存器数据内容。这样，例如当省略第一和第二复制指令时，第三存储指令必须从实际存在数据的工作寄存器Rc(而不是寄存器R1)复制数据并放入实际存在地址的工作寄存器Rs(而非寄存器R3)表示的地址上。
<pre listing-type="program-listing"><![CDATA[Example illustrating scheduling of the loop body only. Entry add R0,Rebp,0×c add R2,Rebp,0×8 add R7,Rebp,0×10 add Rseq,Reip,Length(block) 1dc Rtarg,EIP(target) ldRc,[R0] prot [R0],Aliasl ldRs,[R2] prot [R2],Alias2 ldRecx,[R7] prot [R7],Alias3Loop st[Rs],Rc, & add Rs,Rs,4 & copy Reax，Recx st[R2],Rs,NAC& sub Recx,Reax,1 st[R7],Recx,NAC & andcc R11,Reax,Reax selcc Reip,Rseq,Rtarg & jg Epilog,Loop & commitEpilog FA Alids1 FA Alias2 FA Alias3 j SequentialHost Instruction keyNAC= No Alias Check]]></pre>上述实例示出了安排后的主指令。将会看到，在执行该循环时，序列所需的时钟数要少于从源代码得到的基本目标指令所需的时钟数。因此除了所有其它加速技术以外，所运行联合的操作的总数也少于执行源目标码所需的操作数量。
<pre listing-type="program-listing"><![CDATA[Store Elimination by use of the alias hardware.Entry addR0,Rebp,0×c addR2,Rebp,0×8 addR7,Rebp,0×10 addRseq,Reip,Length(block) ldcRtarg,EIP(target) ld Rc,[R0] prot [R0],Aliasl ;protect the address from loads andstores ld Rs, [R2] prot [R2],Alias2 ;protect the address from loads andstores ld Recx, [R7] prot [R7],Alias3 ;protect the adcress from loads andstoresLoop st [Rs],Rc,& add Rs,Rs,4 & copy Reax，Recx subRecx,Reax,1 & andcc R11,Rsax,Reax selcc Reip,Rseq,Rtarg & jg Epilog,Loop & commitEpilog FA Alias1 FA Alias2 FA Alias3 st [R2],Rs ;writeback the final value of Rs st [R7],Recx ;writeback the final value of Recx j Sequential]]></pre>
本实例所示的最后优化用于别名硬件以节省存储。这节省了循环体内的存储并且只在循环结束部分施行。与最初10条目标指令相比，这将循环体内主指令的数量减少到3条。
虽然以上借助实施例描述了本发明，但是本领域内技术人员可以在不偏离本发明范围和精神的前提下对本发明作出各种修改和变动。例如虽然本发明描述的是X86处理器的仿真，但是它也可以应用于针对其它处理器结构设计的应用程序上，也可以用于运行在虚拟机上的程序，例如P code、Postscript或Java程序等。因此本发明由下面所附权利要求限定。
权利要求
1．一种保护计算机内存储器被写入的系统，计算机包括针对执行主指令集设计的主处理器和从目标指令集翻译至主指令集指令的软件，其特征在于包括硬件装置，用于指示存储器地址是否存储已经被翻译为主指令的目标指令；以及软件装置，它响应存储器地址存储已经被翻译为主指令的目标指令的指示，用于保护对存储器地址的写入直到确保在更新之前不使用与存储器地址相关的翻译。
2．如权利要求1所述的保护存储器被写入的系统，其特征在于所述硬件装置包含旁路缓冲器，它包括多个虚拟地址及其相关物理地址的存储区；以及每个翻译旁路缓冲器存储区上的存储位置。
3．如权利要求1所述的保护存储器被写入的系统，其特征在于保护存储器地址被写入的软件装置使与存储器地址相关的翻译无效。
4．如权利要求1所述的保护存储器被写入的系统，其特征在于所述硬件装置包含旁路缓冲器，它包括多个虚拟地址及其相关物理地址的存储区；以及每个翻译旁路缓冲器存储区上的存储位置；并且保护存储器地址被写入的软件装置使与存储器地址相关的翻译无效。
5．如权利要求1所述的保护存储器被写入的系统，其特征在于保护存储器地址被写入的软件装置去除与存储器地址相关的翻译。
6．如权利要求1所述的保护存储器被写入的系统，其特征在于所述硬件装置包含旁路缓冲器，它包括多个虚拟地址及其相关物理地址的存储区；以及每个翻译旁路缓冲器存储区上的存储位置；并且保护存储器地址被写入的软件装置去除与存储器地址相关的翻译。
7．一种计算机系统，其特征在于包括针对执行主指令集指令的主处理器；用于将来自目标指令集的指令翻译为主指令集的指令的软件；存储被翻译程序的目标指令的存储器；存储从目标指令翻译的执行用主指令的翻译缓冲器；以及硬件装置，用于生成写入访问目标地址的意外事件，所述目标地址存储了已经翻译为主指令的目标指令。
8．如权利要求7所述的计算机系统，其特征在于生成意外事件的硬件装置包含翻译旁路缓冲器，它包括多个最近访问的存储器的虚拟地址及其相关物理地址的存储区，每个存储区包含存储位置，用于指示目标地址上的指令已经被翻译为主指令。
9．如权利要求7所述的计算机系统，其特征在于进一步包含软件装置，它响应对目标地址的写入访问的意外事件，所述目标地址存储已经被翻译为主指令的目标指令，所述软件装置用于保护对存储器地址的写入直到确保在更新之前不使用与存储器地址相关的翻译。
10．如权利要求9所述的计算机系统，其特征在于响应写入访问意外事件的软件装置包含使与存储器地址相关的翻译无效的软件装置。
11．如权利要求9所述的计算机系统，其特征在于响应写入访问意外事件的软件装置包含去除与存储器地址相关的翻译的软件装置。
12．一种响应写入存储器地址的方法，存储器地址包括已经被翻译为主处理器执行的主指令的目标指令，所述方法包括以下步骤对包含已经被翻译为主指令的目标指令的存储器地址进行标记；当试图写入存储器地址时检测已经被标记的存储器地址；以及通过直到确保在更新之前不使用与存储器地址相关的翻译保护存储器地址处的目标指令来响应对已经标记存储器地址的检测。
13．如权利要求12所述的方法，其特征在于标记包含已经被翻译为主指令的目标指令的存储器地址的步骤包括将目标地址已经翻译的指示连同目标指令的物理地址存储在翻译旁路缓冲器的存储区内。
14．如权利要求12所述的方法，其特征在于通过直到确保在更新之前不使用与存储器地址相关的翻译保护存储器地址处的目标指令来响应对已经标记存储器地址的检测的步骤包括生成意外事件以响应检测到已经标记的存储器地址；以及通过在写入存储器地址之前使与存储器地址相关的翻译无效响应意外事件。
15．一种微处理器，其特征在于包含能够执行第一指令集的主处理器；代码词态软件，用于将为包含第二不同指令集的目标处理器编写的程序翻译为主处理器执行的第一指令集的指令；以及存储器控制器，包含地址翻译缓冲器，包括多个记录了用虚拟目标地址表示的最近被访问虚拟目标地址和物理存储器地址的存储区，每个存储区包含指示物理地址处的目标指令是否已经被翻译为主指令的装置；以及响应地址翻译缓冲器存储区内地址的写入访问的装置，其中指示装置指示物理地址处的目标指令已经被翻译为主指令以保护存储器地址的写入直到确保在更新之前不使用与存储器地址相关的翻译。
16．如权利要求15所述的微处理器，其特征在于响应地址翻译缓冲器存储区内地址的写入访问的装置，其中指示装置指示物理地址处的目标指令已经被翻译为主指令以保护存储器地址的写入直到确保在更新之前不使用与存储器地址相关的翻译，包括产生意外事件响应指示的检测的装置；以及响应意外事件以在访问存储器地址之前指示将要进行的后续操作的装置。
17．如权利要求16所述的微处理器，其特征在于指示物理地址处的目标指令是否已经被翻译为主指令的装置包括存储区内的一个存储位置。
18．一种存储器控制器，其特征在于包含地址翻译缓冲器，包括多个记录了用虚拟目标地址表示的最近被访问虚拟目标地址和物理存储器地址的存储区，每个存储区包含指示物理地址处的目标指令是否已经被翻译为主指令的装置；以及响应地址翻译缓冲器存储区内地址的写入访问的装置，其中指示装置指示物理地址处的目标指令已经被翻译为主指令以保护存储器地址的写入直到确保在更新之前不使用与存储器地址相关的翻译。
19．如权利要求18所述的存储器控制器，其特征在于检测存储区内指示以防止物理地址被写入并且在访问地址之前指示后续操作的装置包括产生意外事件响应指示的检测的装置；以及响应意外事件以在访问地址之前指示将要以翻译的主指令进行的后续操作的装置。
20．如权利要求18所述的存储器控制器，其特征在于指示装置包括存储区内的一个存储位置。
全文摘要
一种响应写入存储器地址的方法,存储器地址包括已经被翻译为主处理器执行的主指令的目标指令,所述方法包括以下步骤:对包含已经被翻译为主指令的目标指令的存储器地址进行标记;当试图写入存储器地址时检测已经被标记的存储器地址;以及通过直到确保在更新之前不使用与存储器地址相关的翻译保护存储器地址处的目标指令来响应对已经标记存储器地址的检测。
文档编号G06F12/14GK1286772SQ97182229
公开日2001年3月7日 申请日期1997年8月11日 优先权日1997年8月11日
发明者E·J·凯利, R·F·斯梅利克, M·J·温 申请人:全斯美达有限公司