CN1265204A

CN1265204A - 检测被寻址单元预测失败的存储控制器

Info

Publication number: CN1265204A
Application number: CN97182010A
Authority: CN
Inventors: E·J·凯利; R·F·斯梅利克; M·J·温
Original assignee: Transmeta Inc
Current assignee: Full Simeida LLC; Transmeta Inc
Priority date: 1997-08-11
Filing date: 1997-08-11
Publication date: 2000-08-30
Anticipated expiration: 2017-08-11
Also published as: DE69739078D1; KR20010014095A; JP2001519956A; US5832205A; EP1002271A4; CN1161691C; JP3615770B2; WO1999008188A1; KR100463810B1; ATE412940T1; EP1002271B1; CA2283559C; EP1002271A1; CA2283559A1

Abstract

一种用于微处理器的存储控制器,包含:检测被寻址存储器性质预测失败的装置;以及从这种失败中恢复的装置。

Description

检测被寻址单元预测失败的存储控制器

发明领域

本发明涉及计算机系统，特别是涉及提供改进微处理器的方法和装置。

背景技术

在计算机上运行着成千上万针对特定微处理器系列设计的应用程序。其中为利用“X86”系列微处理器(包括Intel^8088、Intel 8086、Intel 80186 Intel80286、i386、i486以及随后发展的各种奔腾^系列微处理器，它们都是位于加州Santa Clara的Intel公司设计和制造)的计算机(通常称为“IBM兼容个人电脑”)而设计的程序数量最多。针对利用其它系列处理器的计算机也设计有许多程序。由于运行在这些计算机上的应用程序非常多，所以能够为这类计算机(特别是处理X86程序的计算机)所用的微处理器拥有巨大的市场。微处理器市场不仅容量巨大而且获利丰厚。

虽然能够运行大量应用程序的微处理器市场容量巨大而且获利丰厚，但是设计新的有竞争力的微处理器却不那么容易。例如，虽然X86系列的微处理器已经问世多年并且在大多数销售和使用的计算机内都包含这些处理器，但是也只有少数成功的竞争者能够运行X86程序。其中的原因是多方面的。

为了取得成功，微处理器必须能在不高于现有微处理器开销的前提下，与现有处理器一样快地运行针对现有系列处理器设计的所有程序(包括操作系统和已有程序)。此外，为了在经济上取得成功，新的微处理器必须至少在某一方面胜过现有的处理器，从而使买主有选购新微处理器的理由。

要做到使微处理器运行速度与现有微处理器一样快是困难和昂贵的。处理器通过诸如加载、移位、相加、存储和类似的低层次操作之类的基本操作执行指令并且在执行应用程序提供的指令时仅仅响应这类基本操作。例如在诸如X86之类被设计为运行复杂指令集计算机(CSIC)的处理器中，指令在较高的级别上分配待执行的过程，该处理器包含存储所谓微指令的只读存储器(ROM)。每条微指令包含一串基本指令，依照顺序执行这些基本指令将得到高级CISC指令所命令的结果。典型的“A加B”CISC指令经过译码后在ROM内查找地址，执行“A加B”功能指令的微指令就存储在该地址上。微指令加载后，按照顺序执行其基本指令，从而完成“A加B”指令的执行。在这类CSIC计算机中，微指令内基本操作在程序执行过程中绝对不可能发生变化。每条CISC指令只能通过指令译码、寻址和提取微指令以及按照微指令提供的顺序运行基本操作序列完成运行过程。微指令每次运行时都必须遵循同一顺序。

当今运行X86应用程序的处理器利用大量的技术，在合理的性价比前提下提供最快的处理速度。任何采用已知硬件技术提高处理器速度的新处理器都必然会增加处理硬件的复杂度。这增加了硬件成本。

例如超标量微处理器(superscalar)，为了同时执行两个以上的操作，它使用多条处理通道，对此需要一系列额外的需求。在最基本层次上，简单的超标量微处理器将每条应用指令译码为执行应用指令功能的微指令。随后，如果两条微指令不需要相同的硬件资源并且一条微指令的执行不依赖于待处理的另一条微指令的结果，则简单超标量微处理器将这两条微指令安排为同时执行。

更加高级的超标量微处理器一般将每条应用指令译码为一系列的基本指令，从而以最有效的执行次序重新排序和安排这些基本指令的执行。这需要每条基本操作都能单独寻址和提取。为了完成重新排序，处理器必须确保需要其它基本指令产生数据的基本指令在其他指令产生所需数据之后执行。这类超标量微处理器必须确保同时执行的两条基本指令不需要使用同一硬件资源。而且还必须在完成分支转移操作之前解决条件分支转移。

因此超标量微处理器需要大量的硬件来比较基本指令之间的相互关系，重新排序和安排执行任何指令的基本指令的顺序。随着处理通道数的增加，完成这些超标量加速技术的硬件数量和成本将以二次方的速度增加。所有这些硬件需求都增加所涉及电路系统的复杂性和成本。在处理微指令过程中，当每次执行一条应用指令时，超标量微处理器都必须使用比较复杂的寻址和提取硬件来提取每条基本指令，都必须根据其它基本指令和硬件使用状态重新排序和重新安排这些基本指令，并且随后还必须执行所有重新安排后的基本指令。由于每次执行一条应用指令时都必须通过整个硬件序列，所以限制了超标量处理器能够执行指令的速度。

即使利用各种硬件技术提高了处理速度，由此带来的硬件复杂性也大大增加了这类微处理器的成本。例如，Intel i486 DX4处理器采用大约150万个晶体管。但是如果要在诸如Intel奔腾^之类的基本超标量处理器中通过增加硬件来利用两条通道完成指令处理所需的依赖性检查和执行调度安排，则需要300多万个晶体管。在Intel Pentium Pro^TM微处理器中，为了能重新排序从不同目标指令导出的基本指令，提供预测执行，完成寄存器更名和提供转分支移预测，增加到超过600多万个晶体管。由此可见，每次为提高运算速度而增加硬件已使最新一代微处理器的晶体管数量出乎寻常地增加。

即使采用这些已知的技术，但是由于现有微处理器制造商已经采用了绝大部分经济可行的技术来提高现有微处理器的运行速度，所以也不可能制造出更快的微处理器。这样，设计更快的处理器就成了一项非常困难和费钱的工作。

降低处理器成本也是非常困难的。如上所述，制造具有足够能力处理器的硬件加速技术非常昂贵。如果要设计一种新的处理器，必须拥有生产硬件的设备。由于芯片制造商一般不会投资小批量器件，所以难以获得这类设备。生产芯片制造设备所需的资本投资如此巨大，以致于超出了大多数公司力所能及的范围。

即使设计出的新处理器能够至少以竞争处理器同样快的速度运行所有针对一类处理器系列设计的应用程序，竞争处理器在价格中也包含了足够的利润，从而确保其能面对竞争对手作大幅度削价。

虽然通过增加硬件复杂度来设计富有竞争力的处理器是非常困难的，但是可以有另一种运行针对某一特定系列微处理器(目标微处理器)设计的应用程序(目标应用程序)的方法，它在另一种更快的微处理器(主微处理器)上用软件仿真目标微处理器。由于这仅仅需要增加一定形式的仿真软件以在更快的微处理器上运行应用程序，所以是一种成本日趋低廉的方法。仿真器软件将针对目标处理器系列编写的应用程序目标指令改写为能够被主微处理器执行的主指令(hostinstruction)。随后这些被改写的指令在较快主微处理器上操作系统的控制下运行。

有许多种不同的设计可以使目标应用程序运行在处理器速度快于目标计算机处理器的主计算机上。由于从理论上讲，精简指令集(RISC)微处理器更为简单而且速度较其它类型处理器更快，所以利用仿真软件执行目标程序的主计算机都采用RISC微处理器。

但是即使利用仿真器软件的RISC计算机系统能够运行X86(或其它)程序，它们的运行速度通常也明显慢于X86计算机系统运行同一程序的速度。而且这些仿真器程序常常无法运行所有或大量现有的目标程序。

仿真器程序无法象目标微处理器那样快地运行目标程序的原因相当复杂并且需要对不同的仿真操作有所了解。图1包括一系列的示意图，它们表示不同类型微处理器执行目标应用程序的方式。

在图1(a)中，诸如Intel X86微处理器之类的典型CISC微处理器运行着设计在目标微处理器运行的目标应用程序。如图所示，应用程序运行在利用CISC操作系统(例如X86计算机使用的MS DOS、Windows 3.1、Windows NT和OS/2)的CISC处理器上，这些操作系统提供了访问计算机硬件的接口。典型情况是选择应用程序的指令，只通过操作系统提供的访问使用计算机设备。因此操作系统处理允许应用程序访问计算机存储器和各种输入/输出设备的操作。目标计算机包含能够被操作系统识别的存储器和硬件，并且目标应用程序对操作系统的调用使操作系统设备驱动程序在目标计算机定义的设备上产生预期的操作。应用程序的指令在处理器上执行，它们被变换为可以被处理器执行的操作，这些操作由微代码或汇编微代码的更加基本的操作具体实现。如上所述，每次执行复杂的目标指令时，指令都调用以微代码(或同一基本操作组)形式存储的同一子程序。执行的总是同一子程序。如果处理器是超标量的，则执行目标指令的这些基本操作常常可以被处理器以上述方式，利用各种处理通道进行重新排序、重新安排和执行；但是子程序仍然被提取和执行。

在图1(b)中，诸如用于苹果Macintosh计算机中的PowerPC之类的典型RISC微处理器运行着针对图1(a)CISC处理器运行设计的同一目标应用程序。如图所示，目标应用程序至少借助部分目标操作系统运行于主处理器上以响应目标应用程序生成的一部分调用。典型的是对目标操作系统应用类部分的调用，用来在显示器上提供图形接口和通常是应用类程序的小型工具程序。目标应用程序和目标操作系统的这些部分由诸如SoftPC^之类的软件仿真器变换，它将目标应用程序和应用类目标操作系统配备的指令分解为主处理器及其主操作系统能够执行的指令。主操作系统提供了访问RISC计算机的存储器和输入/输出硬件的接口。

但是主RISC处理器及其RISC计算机中相关的硬件设备通常与这样一些设备有相当大的差异，它们与针对目标应用程序而设计的处理器相关；并且目标应用程序提供的各种指令被设计为使目标操作系统的设备驱动程序在访问目标计算机各部分时协同工作。因此对于将目标应用程序指令变换为主操作系统能够利用的基本主指令的仿真程序而言，它必须在某种程度上将操纵目标计算机内硬件设备的操作与主系统硬件设备能够实现的操作联系起来。由于目标设备并不等同于主计算机的设备，所以通常需要由仿真器软件生成响应目标应用程序指令的虚拟设备来完成主系统无法实现的操作。有时候仿真器需要通过主操作系统生成从这些虚拟设备至主硬件设备的链接，这些主硬件设备虽然是真实存在，但是要由主操作系统按照不同的方式寻址。

由于众多的原因，以这种方式运行的目标程序速度较慢。首先，来自目标应用程序和目标操作系统的每条目标指令都必须由仿真器变换为主处理器使用的主基本功能。如果目标应用程序是针对诸如X86之类的CSIC机而设计的，则目标指令是变长度的并且相当复杂，因此将它们变换为主基本指令就相当费事。源目标指令首先被译码，并确定构成目标指令的主基本指令序列。随后确定每串基本主指令序列的地址，提取每串基本主指令序列，并按照顺序或者不按照顺序执行这些基本主指令。每次执行指令时都必须由仿真器将目标应用程序和操作系统指令变换为主处理器理解的主指令，这需要大量额外的步骤，因此减慢了仿真处理的速度。

其次，许多目标指令包括了对由特定硬件设备执行了操作的引用，这些特定硬件设备在目标计算机中起着特殊的作用，但在主计算机中却不存在。为了执行该类操作，仿真软件必须通过已有的主操作系统与主计算机的硬件设备实现软件连接或者配备一台虚拟硬件设备。用软件仿真另一种计算机硬件是非常困难的。仿真软件必须为每一个目标应用调用主操作系统生成各种虚拟设备；并且每台虚拟设备都必须对实际主设备提供调用。硬件设备仿真要求在目标指令使用设备时从存储器中提取表示指令所需虚拟设备代码并进行运行以实现设备功能。解决问题的这些方法在执行指令序列时都额外增加了一系列的操作。

仿真问题的复杂化是目标应用要解决各种意外事件的结果，为了使计算机系统运行，目标计算机的硬件和目标操作系统要对这些意外事件作出处理。当处理目标计算机运行期间的意外事件时，一般必须通过调用微代码序列完成保存发生意外事件时刻计算机状态的操作，必须检索正确的意外事件处理器(handler)，必须妥善处理意外事件，并且必须找到程序继续运行下去的正确入口。有时候这要求程序返回至发生意外事件之处目标计算机的状态，而其它时候进入意外事件处理器提供的分支转移。在任一情况下，都必须在某种程度上对完成这些操作所需的目标计算机硬件和软件进行仿真。由于必须在发生意外事件时可以得到正确的目标状态以供适当执行，仿真器必须始终精确跟踪该状态以准确响应这些意外事件。在现有技术中，这要求每条指令的执行必须按照目标应用程序提供的顺序，因为只有这种方式能够保持正确的目标状态。

而且现有技术的仿真器出于其它原因，总是需要保持目标应用程序的执行顺序。目标指令可以有两种，一种作用于存储器而另一种作用于存储器映射的输入/输出(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)中示出另一种仿真方法，它利用软件在识别不同指令集的计算机上运行为第一指令集编写的部分应用程序。这种形式的仿真软件一般由程序员使用，他们将一个应用程序从一种计算机系统移植到另一种计算机系统上。典型的情况是目标应用程序针对除运行仿真器的主机以外的一些目标计算机而设计。仿真器软件分析目标指令，将这些指令翻译为可以在主机上运行的指令，并且将这些主指令存入高速缓冲存储器内供再次使用。这种动态翻译和高速缓存可以使应用程序部分运行得非常快。这种形式的仿真器一般与软件跟踪工具一起使用，该工具提供了正在运行的目标程序详细的运行信息。跟踪工具的输出又被用来启动分析程序，对跟踪信息进行分析。

为了确定代码实际上是如何工作的，这种类型的仿真器与主机上的主操作系统协同运行，配备了主操作系统未提供的虚拟硬件，并且将设计应用软件针对的计算机的操作映射到主机硬件资源以执行正在运行的程序的操作。这种硬件的软件虚拟化和对主计算机的映射可能非常慢并且很不完善。

而且由于常常需要多条主指令执行一条目标指令，所以可能产生包括故障和陷井在内的意外事件，这需要目标操作系统的意外事件处理器，并且使主机在与目标指令边界无关的位置上中止处理主指令。当发生这种情况时，由于主处理器和存储器的状态不正确，所以无法正确处理意外事件。如果出现这种情况，仿真器必须停止运行并重新运行并返回跟踪产生意外事件的操作。因此虽然这种仿真器能够非常快地运行目标代码序列，但是却没有办法从这些意外事件中恢复过来，因此无法快速运行应用程序中任何相当大的一块。

由于仿真器、跟踪器和相关的分析器所完成的功能是直接产生新的程序或者将旧程序移植到另一种机器上，因而就仿真器软件运行速度而言很少有异议，因此这不是这种形式仿真器固有的问题。即，程序员通常对仿真器生成的代码在主机上运行得有多快并不感兴趣，他们感兴趣的是仿真器是否能生成可在为其设计的机器上执行并在该机器上运行快速的代码。因此除了编程目的以外，这种类型的仿真软件不能提供使第一指令集编写的应用程序能运行在不同类型的微处理器上的方法。这种仿真软件的实例在题为“Shade：A Fast Instruction-Set Simulatorfor 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 morpgingsoftware”)，二者结合成为比已知的竞争性微处理器功能更强大的微处理器。具体而言，形态主机是一种包含硬件增强的处理器，当发生意外事件或者错误时它立即恢复为目标计算机的状态，而代码形态化软件将目标程序的指令翻译为形态主机的形态主机指令，并在需要时用正确的目标状态代替工作状态以响应意外事件或错误，从而进行正确的重新翻译。代码形态化软件也可以包括提高处理速度的各种进程。与所有速度极快的现有技术微处理器通过提供硬件来提高处理速度的做法不同，改进的微处理器借助代码形态化软件在可以选择的阶段运用加速增强技术。假定在代码形态化软件中运用提速技术使得可以采用复杂程度较低但运行速度比现有技术微处理器更快而价格大为降低的硬件实现形态主机。作为比较，在一个用包含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比特进行设定。该指示提醒指令已经翻译；并且如果试图向目标地址写入内容，则将导致意外事件，可能使得翻译结果无效或者被除去。

新增的加强形态主机性能的硬件电路可以使正常存储在存储器内但经常用于操作执行的数据在执行单元寄存器内被复制(或者给以“别名”)以便节省从存储器内提取数据的时间。在一个实施例中，为此将形态主机设计为响应“加载和保护”命令，将存储器数据复制到图10所示执行单元110的工作寄存器111内并将存储器地址放置在该单元寄存器112内。与地址寄存器相连的是比较器113。在翻译期间，比较器接收加载地址并将其存储在指向存储器的选通存储缓冲器内。如果加载或存储的存储器地址与寄存器112(或者根据实施方案是另外的寄存器)内的地址比较，则生成意外事件。形态主机软件响应意外事件，确保存储器地址与寄存器保存的是同一正确数据。在一个实施例中，为此重新进行翻译并在不用执行寄存器内“别名”数据的情况下重新执行。解决这个问题的其它可行方法是用最近的存储器数据更新寄存器或用最近的加载数据更新存储器。

本领域内的技术人员将会发现，微处理器可以通过电路形式与典型的计算机单元连接从而构成诸如图9所示的计算机。显而易见，当微处理器用于现代X86计算机时，它可以通过处理器总线与存储器和总线控制电路连接。存储器和总线控制电路提供了对主存储器的访问，也提供了对与微处理器一起使用的高速缓存的访问。存储器和总线控制线路还提供了对诸如PCI或其它局部总线的访问，通过这些总线对I/O设备进行访问。特定的计算机系统取决于由本发明微处理器所替代的典型微处理器一起使用的电路。

为了描述处理器的操作和加快执行速度的方法，这里的实例是将少量X86目标代码翻译为主基本指令。实例涉及了将X86目标指令翻译为形态主机指令的过程，包括本发明微处理器所作的优化、重新排序和重新安排各种步骤。通过以下描述的过程，本领域内技术人员将会理解利用目标处理器执行源指令所需的操作与主处理器上执行翻译所需操作之间的差别。

用C语言源代码编写的源指令描述了一个非常简单的循环操作。当每次循环后都减一的变量“n”大于“0”时，数值“c”存储在指针“^*s”指示的地址处，每次循环之后该指针都增一。

Original C code

    while((n--)＞0){
 
        ★s++＝c

    }
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
				
				<dp n="d24"/>
    Win32×86 instructions produced by a compiler compiling this C code.

    mov    ％ecx，[％ebp+0×c]                     // load c from memory address into the

    ％ecx

    mov    ％eax，[％ebp+0×8]                     // load s from memory address into the

    ％eax

    mov    [％eax]，％ecx                          // store c into memory address s held

    in ％eax

    add    ％eax，#4                               // increment s by 4.

    mov    [％ebp+0×8]，％eax                     // store(s+4)back into memory

    mov    ％eax，[％ebp+0×10]                    // load n from memory address into the

    ％eax

    lea    ％ecx，[％eax-1]                        // decrement n and store the result in

    ％ecx

    mov    [％ebp+0×10]，％ecx                    // store(n-1) into memory

    and    ％eax，％eax                            // test n to set the condition codes

    jg     .-0×1b                                 // branch to the top of this section if

    “n＞0”

在实例的第一部分，执行用C语言语句定义的操作的每条X86汇编语言指令用汇编语言操作助记符列示，后面跟着涉及特定基本操作的参数。每条指令的注释对操作作了解释。虽然所示的执行顺序可以由目标处理器改变，但是每次执行目标C语言指令的循环时每条汇编语言指令都必须执行。因此，如果循环执行100次，则所示的每条指令也必须执行100次。

Shows each X86 Instruction shown above followed by the host instructions necessary
to implement the X86 Instruction.
mov    ％ecx，[％ebp+0×c]                      // load c from memory address into ecx
add    R0，Rebp，0×c                           ； form the memory address and put it in
R0
ld     Recx，[R0]                               ； load c from memory address in R0 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
Reax
add    ％eax，#4                                // increment s by 4
add    Reax，Reax，4                            ； increment s by 4
mov    [％ebp+0×8]，％eax                      // store(s+4) back into memory
add    R5，Rebp，0×8                           ； form the memory address and put it in
R5
st     [R5]，Reax                               ； store(s+4) back into memory
mov    ％eax，[％ebp+0×10]                     // load n from memory address into ％eax
				
				<dp n="d25"/>
add    R7，Rebp，0×10                        ； form the memory address and put it in
R7
ld     Reax，[R7]                             ； load n from memory address into the
Reax
lea    ％ecx，[％eax-1]                       // decrement n and store the result in
％ecx
sub    Recx，Reax，1                          ； decrement n and store the result in
Recx
mov    [％ebp+0×10]，％ecx                   // store(n-1) into memory
add    R9，Rebp，0×10                        ； form the memory address and put it in
R9
st     [R9]，Recx                             ； store(n-1) into memory
and    ％eax，％eax                           // test n to set the condition codes
andcc  R11，Reax，Reax                              ； test n to set the condition
codes
jg     .-0×1b                                // branch to the top of this section if
“n＞0”
jg     mainloop，mainloop                     ； jump to the main loop
Host  Instruction key：

       ld＝load                               add＝ADD                    st＝store

       sub＝subtract                          jg＝jump if condition codes indicate

       greater

       andcc＝and set the condition codes

下一实例描述了执行C语言指令的同一目标基本指令。但是在每条基本目标指令之后列出了在微处理器特定实施例中完成同一操作所需的基本主指令，其中形态主机为针对上述方式设计的VLIW处理器。值得注意的是，用正式目标寄存器作为影像的主寄存器用X86寄存器名的前面加“R”表示，因此例如Reax表示与EAX正式目标寄存器相关的工作寄存器。

Adds host instructions necassary to perform X86 address computation and upper and
lower segment limit checks.
mov    ％ecx，[％ebp+0×c]                // load c
add    R0，Rebp，0×c                      ；form logical address into R0
chkl   R0，Rss_limit                ； Check the logical address against segment
lower  limit
chku   R0，R_FFFFFFFF               ； Check the logical address against segment
upper  limit
add    R1，R0，Rss_base                    ；add the segment base to form the
linear address
ld     Recx，[R1]                          ；load c from memory address in R1 into
Recx
mov    ％eax，[％ebp+0×8]                 // load s
add    R2，Rebp，0×8                      ；form logical address into R0
chkl   R2，Rss_limit                ； Check the logical address against  segment
lower  limit
chku   R2，R_FFFFFFFF               ； Check the logical address against segment
upper  limit
add    R3，R2，Rss_base                    ；add the segment base to form the
linear address
ld     Reax，[R3]                          ；load s from memory address in R3 into
Ra
mov    [％eax]，％ecx                      // store c into [s]
chku   Reax，Rds_limit              ； Check the logical address against segment
upper  limit
add    R4，Reax，Rds_base                  ；add the segment base to form the
linear address
st     [R4]，Recx                          ；store c into memory address s
add    ％eax，#4                           // increment s by 4
addcc  Reax，Reax，4                       ；increment s by 4
mov    [％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_base                    ；add the segment base to form the
linear address
st     [R6]，Reax                          ；store(s+4) to memory address in R6
				
				<dp n="d27"/>
  mov    ％eax，[％ebp+0×10]                // load n
  add    R7，Rebp，0×10                     ；form logical address into R7
  chkl   R7，Rss_limit                ； Check the logical address against segment
  lower  limit
  chku   R7，R_FFFFFFFF               ； Check the logical address against segment
  upper  limit
  add    R8，R7，Rss_base                    ；add the segment base to form the
  linear address
  ld     Reax，[R8]                          ；load n from memory address in R8 intoReax
  lea    ％ecx，[％eax-1]                    // decrement n
  sub    Recx，Reax，1                       ；decrement n
  mov    [％ebp+0×10]，％ecx                // store(n-1)
  add    R9，Rebp，0×10                     ；form logical address into R9
  chkl   R9，Rss_limit                ； Check the logical address against segment
  lower  limit
  chku   R9，R_FFFFFFFF               ； Check the logical address against segment
  upper  limit
  add    R10，R9，Rss_base                   ；add the segment base to form the
  linear address
  st     [R10]，Recx                         ；store n-1 in Recx into memory using
  address in R10
  and    ％eax，％eax                        // test n to set the condition codes
  andcc  R11，Reax，Reax                           ；test n to set the condition
  codes    
  jg     .-0×1b                      // branch to the top of this section if
  “n＞0“

下一实例表示每条基本目标指令的主基本指令加法，代码形态化软件可以利用其产生目标操作所需的地址。值得注意的是，主地址生成指令只是在采用代码形态化软件而非地址生成硬件来生成地址的微处理器实施例中才需要。在诸如X86微处理器之类的目标处理器中，地址是利用地址生成硬件生成的。在这种实施例中，无论何时产生了地址，都完成了计算；并且还加入主基本指令以检查地址值从而确定计算的地址是否在合适的X86段边界内。

Adds instructions to maintain the target X86 instruction pointer“eip”and
the commit instructions that use the special morph host hardware to update X86 state.
mov    ％ecx，[％ebp+0×c]               // load c
add    R0，Rebp，0×c
chkl   R0，Rss_limit
chku   R0，R_FFFFFFFF
add    R1，R0，Rss_base
ld     Recx，[R1]
add    Reip，Reip 3                      ；add X86 instruction length to
eip in Reip
commit                                   ；commits working state to
official state
				
				<dp n="d28"/>
mov    ％eax，[％ebp+0×8]                         // load s
add    R2，Rebp，0×8
chkl   R2，Rss_limit
chku   R2，R_FFFFFFFF
add    R3，R2，Rss_base
ld     Reax，[R3]
add    Reip，Reip，3                               ；add X86 instruction length to
eip in Reip    
commit                                             ；commits working state to
official state
mov    [％eax]，％ecx                              // store c into [s]
chku   Reax，Rds_limit
add    R4，Reax，Rds_base
st     [R4]，Recx
add    Reip，Reip，2                               ； add X86 instruction length to
eip in Reip
commit                                             ； commits working state to
official state
add    ％eax，#4                                   // increment s by 4
addcc  Reax，Reax，4
add    Reip，Reip，5                               ； add X86 instruction length to
eip in Reip
commit                                             ； commits working state to
official state
mov    [％ebp+0×8]，％eax                         // store(s+4)
add    R5，Rebp，0×8
chkl   R5，Rss_limit
chku   R5，R_FFFFFFFF
add    R6，R5，Rss_base
st     [R6]，Reax
add    Reip，Reip，3                               ； add X86 instruction length to
eip in Reip
commit                                             ； commits working state to
official state
mov    ％eax，[％ebp+0×10]                        // load n
add    R7，Rebp，0×10
chkl   R7，Rss_limit
chku   R7，R_FFFFFFFF
add    R8，R7，Rss_base
ld     Reax，[R8]
add    Reip，Reip，3                                ； add X86 instruction length to
eip in Reip
commit                                              ； commits working state to
official state
				
				<dp n="d29"/>
lea    ％ecx，[％eax-1] 　　　　　　　　　 // decrement n
sub    Recx，Reax，1
add    Reip，Reip，3                       ； add X86 instruction length to
eip in Reip
commit                                     ； commits working state to
official state
mov    [％ebp+0×10]，％ecx                // store(n-1)
add    R9，Rebp，0×10
chkl   R9，Rss_limit
chku   R9，R_FFFFFFFF
add    R10，R9，Rss_base
st     [R10]，Recx
add X86 instruction length to
add     Reip，Reip，3
eip in Reip                                 ； commits working state to
official state
and    ％eax，％eax                         // test n
andcc  R11，Reax，Reax
add    Reip，Reip，3                        ； commits working state to
commit
official state
jg     .-0×1b                              // branch“n＞0”
add    Rseq，Reip，Length(jg)
ldc    Rtarg，EIP(target)
selcc  Reip，Rseq，Rtarg                    ； commits working state to
commit
official state
jg     mainloop，mainloop
Host  Instruction key；

       commit＝copy the contents of the working registers to the

       official target registers and send working stores to memory

本实例示出于每组基本主指令的两步相加，在执行了完成每条基本目标指令所需的主指令后更新正式目标寄存器并将选通存储缓冲器内未动用的值调拨入存储器。显而易见，在每种情况下，目标指令的长度与工作指令指针寄存器(Reip)内的值相加。随后执行调拨指令。在实施例中，调拨指令对影像成其相关正式目标寄存器的工作寄存器的当前值进行复制并将指定选通存储缓冲器位置的指针值从紧靠未调拨存储数据之前移动至紧靠这些存储数据之后从而将它们放入存储器。

显而易见的是上面最后示出的指令清单都是构成原始目标汇编语言指令的主指令翻译所需的指令。如果翻译操作在该处停止，则基本主指令的数量将远远大于目标指令数量(大约是6倍)，并且执行时间将超过在目标处理器上执行的时间。但是此时尚未对指令进行过重新排序、优化和重新安排。

如果指令要被运行但只是一次，则完成指令进一步重新排序和其它优化所需的时间可能超过此时执行翻译的时间。如果这样，微处理器实施例将在此处停止翻译，存储翻译结果，随后执行翻译指令以确定是否发生意外事件或错误。在本实施例中，重新排序其它优化步骤仅仅发生在经确定某一翻译操作将进行多次或者需要优化时。例如通过在每条翻译指令内放入对翻译执行进行计数并在计数值达到某一数值时产生意外事件(或转移)的主指令来实现。意外事件(或转移)将操作转移至代码形态化软件，由其进行下述部分或所有优化以及任何适于该翻译操作的其它优化。第二种确定翻译指令执行次数和是否需要优化的方法是以一定的频度或者根据一些统计依据中断翻译指令的执行，并优化该时刻运行的任何翻译指令。这最终使得最经常运行的指令得到了优化。另一种方案是对每一条特定类型的主指令进行优化，例如生成循环的主指令或者运行次数可能最多的主指令。

    Optimization

    ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

    Assumes 32 bit flat address space whlch allows the elimination of segment base
    additions and some limit checks.

           Win32 uses Flat 32b segmentation

           Record Assumptions：

                  Rss_base＝＝O

                  Rss_limit＝＝O

                  Rds_base＝＝O

                  Rds_limit＝＝FFFFFFFF
                  SS and DS protection check

        mov    ％ecx，[％ebp+0×c]                          // load c

        add    R0，Rebp，0×c

        chku   R0，R_FFFFFFFF

        ld     Recx，[R0]

        add    Reip，Reip，3

        commit

        mov    ％eax，[％ebp+0×8]                          // load s

        add    R2，Rebp，0×8

        chku   R2，R_FFFFFFFF

        ld     Reax，[R2]

        add    Reip，Reip，3

        commit
				
				<dp n="d31"/>
mov    [％eax]，％ecx                        // store c into [s]
chku   Reax，R_FFFFFFFF
st     [Reax]，Recx
add    Reip，Reip，2
commit
add    ％eax，#4                             // increment s by 4
addcc  Reax，Reax，4
add    Reip，Reip，5
commit
mov    [％ebp+0×8]，％eax                   // store(s+4)
add    R5，Rebp，0×8
chku   R5，R_FFFFFFFF
st     [R5]，Reax
add    Reip，Reip，3
mov    ％eax，[％ebp+0×10]                  // load n
add    R7，Rebp，0×10
chku   R7，R_FFFFFFFF
ld     Reax，[R7]
add    Reip，Reip，3
commit
lea    ％ecx，[％eax-1]                      // decrement n
sub    Recx，Reax，1
add    Reip，Reip，3
commit
mov    [％ebp+0×10]，％ecx                  // store(n-1)
add    R9，Rebp，0×10
chku   R9，R_FFFFFFFF
st     [R9]，Recx
add    Reip，Reip，3
commit
and    ％eax，％eax                          // test n
andcc  R11，Reax，Reax
add    Reip，Reip，3
commit
jg     .-0×1b                               // branch“n＞0”
add    Rseq，Reip，Length(jg)
ldc    Rtarg，EIP(target)
selcc  Reip，Rseq，Rtarg
commit
jg     mainloop，mainloop
				
				<dp n="d32"/>
        mov    ％ecx，[％ebp+0×c]                 // load c

        add    R0，Rebp，0×c

        ld     Recx，[R0]

        add    Reip，Reip，3

        commit

        mov    ％eax，[％ebp+0×8]                 // load s

        add    R2，Rebp，0×8
        ld     Reax，[R2]

        add    Reip，Reip，3

        commit

        mov    [％eax]，％ecx                      // store c into [s]

        st     [Reax]，Recx

        add    Reip，Reip，2

        commit

        add    ％eax，#4                           // increment s by 4

        addcc  Reax，Reax，4

        add    Reip，Reip，5

        commit

本实例示出了可以利用改进型微处理器实现的优化步骤的第一步。在优化阶段，就象代码形态化软件的许多其它操作一样，假定是有优化结果的。特定的优化操作假定作为为X86系列处理器普通存储器模型编写的目标应用程序作为32位程序将继续保持原样。将会注意到是，这种假设只针对X86系列而对其它被仿真的处理器系列并非必要。

如果假设成立，则在X86应用程序中所有的段都被映射至相同的地址空间。这使得可以减少X86分段处理所需的基本主指令。显而易见，段值开始时被设定为零。随后，数据基地址也被设定为零，并且上限被设定为最大可用存储空间。随后在执行目标基本指令的每组基本主指令中，都省略了分段所需的对段基值的检查和段基地址的计算。这减少了用于需要寻址功能的每条目标基本指令的两条主基本指令执行循环的次数。此时仍然需要主指令检查存储空间上限。

值得注意的是，这种优化需要对应用程序是否采用32位普通存储器模型作出预测。如果不是这样的情况，则由于主循环要实现的目的地址的控制转移并检查出源地址假设与目的地址假设不匹配，所以将会发现错误。随后将进行新的翻译操作。这种技术非常常用并且被应用于各种分段操作和其它“模式”不经常变化的情况，诸如调试、系统管理模式或“实”模式之类的“模式”。

    mov    [％ebp+0×8]，％eax                 // store(s+4)

    add    R5，Rebp，0×8

    st     [Rs]，Reax

    add    Reip，Reip，3
 
    commit

    mov    ％eax，[％ebp+0×10]                // load n

    add    R7，Rebp，0×10

    ld     Reax，[R7]

    add    Reip，Reip，3

    lea    ％ecx，[％eax-1]                    // decrement n

    sub    Recx，Reax，1

    add    Reip，Reip，3

    commit

    mov    [％ebp+0×10]，％ecx                // stcre(n-1)

    add    R9，Rebp，0×10

    st     [R9]，Recx

    add    Reip，Reip，3

    commit

    and    ％eax，％eax                        // test n

    andcc  R11，Reax，Reax

    add    Reip，Reip，3

    commit    
       jg     .-0×1b                            // branch“n＞0”

    add    Rseq，Reip，Length(jg)

    ldc    Rtarg，EIP (target)

    selcc  Reip，Rseq，Rtarg

    commit

    jg     mainloop，mainloop

    Host  Instruction key：
           selcc＝Select one of the source registers and copy its
 
           contents to the destination register based on the condition

           codes.
				
				<dp n="d34"/>
    Notation：[...] indicates an address expression for a memory operand.

    In the example above，the address for a memory operand is formed from

    the contents of a register added to a hexadecimal constant indicated

    by the Ox prefix. Target registers are indicated with the ％ prefix，

    e.g.％ecx is the ecx register. The destination of an operation is to

    the left.

    Target instruction key：

          jg＝jump if greater

          mov＝move

          lea＝load effective address

          and＝AND

上述实例示出了优化步骤的下一阶段，其中的预测翻译操作避免了存储上限边界的检查，这只对于穿越位于存储器地址空间顶部的存储器参考位置的未对准页面才需要。这种假设的失效由硬件或软件定位工具检查。这减少了对需要寻址的每条目标基本指令用另一主基本指令翻译的量。这种优化需要以前所作的假定，应用程序使用32位普通存储器模型并且预测到指令得到了定位。如果上述假设和预测都得不到满足，则当执行翻译指令时将会失效；并且需要重新翻译。

    Detect and eliminate redundant address calculations.The example shows the code

    after eliminating the redundant operations.

    mov     ％ecx，[％ebp+0×c]                   // load c

    add     R0，Rebp，0×c

    ld      Recx，[R0]
 
    add     Reip，Reip，3

    commit
				
				<dp n="d35"/>
mov   ％eax，[％ebp+0×8]                     // load s
add   R2，Rebp，0×8
ld    Reax，[R2]
add   Reip，Reip，3
commit
mov   [％eax]，％ecx                          // store c into [s]
st    [Reax]，Recx
add   Reip，Reip，2
commit
add   ％eax，#4                               // increment s by 4
addcc Reax，Reax，4
add   Reip，Reip，5
commit
mov   [％ebp+0×8]，％eax                     // store(s+4)
st    [R2]，Reax
add   Reip，Reip，3
commit
mov   ％eax，[％ebp+0×10]                    // load n
add   R7，Rebp，0×10
ld    Reax，[R7]
add   Reip，Reip，3
commit
lea   ％ecx，[％eax-1]                        // decrement n
sub   Recx，Reax，1
add   Reip，Reip，3
commit
mov   [％ebp+0×10]，％ecx                    // store(n-1)
st    [R7]，Recx
add   Reip，Reip，3
commit
and   ％eax，％eax                            // test n
andcc R11，Reax，Reax
add   Reip，Reip，3
commit
jg    .-0×1b                                 // branch“n＞0”
add   Rseq，Reip，Length(jg)
ldc   Rtarg，EIP(target)
selcc Reip，Rseq，Rtarg
commit
jg    mainloop，mainloop

本实例示出了下一步优化，其中省略了公共的主指令表达方式。具体而言，在翻译第二条目标基本指令时，工作寄存器Rebp(表示X86处理器堆栈基点寄存器的工作寄存器)内的值与偏移值0×8相加并放入主工作寄存器R2。将会注意到的是，除了将加法结果放入工作寄存器R5以外，在前面的实例中，翻译目标基本指令5时进行的是同一操作。因此当主基本指令5正要出现时工作寄存器R5内放入的值已经存在于工作寄存器R2。这样主加法指令可以省略翻译目标基本指令5；将工作寄存器R2的值复制到工作寄存器R5内。同样，由于在翻译目标基本指令6时已经完成了将工作寄存器Rebp的值与偏移值0×10相加的步骤并且结果驻留在寄存器R7内，所以在翻译目标基本指令8时可以省略该步骤。值得注意的是这种优化不依赖于预测，因此不会失效或者需要重新翻译。

    Assume that target exceptions will not occur within the translation so delay updating

    elp and target state.

    mov     ％ecx，[％ebp+0×c]                     // load c

    add     R0，Rebp，0×c

    ld      Recx，[R0]

    mov     ％eax，[％ebp+0×8]                     // load s

    add     R2，Rebp，0×8

    ld      Reax，[R2]

    mov     [％eax]，％ecx                          // store c into [s]

    st      [Reax]，Recx

    add     ％eax，#4                               // increment s by 4

    add     Reax，Reax，4

    mov     [％ebp+0×8]，％eax                     // store(s+4)

    st      [R2]，Reax

    mov     ％eax，[％ebp+0×10]                    // load n

    add     R7，Rebp，0×10

    ld      Reax，[R7]

    lea     ％ecx，[％eax-1]                        // decrement n

    sub     Recx，Reax，1
				
				<dp n="d37"/>
       mov   [％ebp+0×10]，％ecx                        // store(n-1)

       st    [R7]，Recx

       and   ％eax，％eax                                // test n

       andcc R11，Reax，Reax

       jg    .-0×1b                                     // branch“n＞0”

       add   Rseq，Reip，Length(block)
 
       ldc   Rtarg，EIP(target)

       selcc Reip，Rseq，Rtarg

       commit

       jg    mainloop，mainloop

上述实例示出了一种优化步骤，它预测构成整个翻译操作的基本目标指令的翻译能够不发生意外事件就完成。如果符合预测情况，则无需在执行一条目标基本指令的每一主基本指令序列结束时更新正式目标寄存器或者调拨存储缓冲器内的未动用存储结果。如果预测为真，则只需在目标基本指令序列结束时更新正式目标寄存器并且存储内容只需被调拨一次。这可以省略两条执行每一基本目标指令的基本主指令。它们被一条更新正式目标寄存器并将未动用存储内容调拨入存储器的主基本指令代替。

显而易见的是，其它的预测操作也极有可能是正确的预测。如果预测保持为真值，那么该步骤与现有仿真技术比就有极大的优势。它使所有执行目标基本指令整个序列的基本主指令归类为一个序列从而可以对所有主基本指令一起逐条优化。这有利于在采用超长指令字技术优点的形态主机上并行运行大量的操作。由于有更多的优化选择，所以可以采用大量的其它优化。但是如果预测情况失真并且在执行循环时发生意外事件，则由于直到实际执行主指令序列后才发生调拨操作，所以正式目标寄存器和存储器保存的是目标基本指令序列开始时的正式目标状态。从意外事件恢复所需的操作是回卷未动用的存储内容，使正式寄存器回卷入工作寄存器并在序列开始时重新翻译目标基本指令。这种重新翻译一次翻译一条目标指令，并且在代表每条目标基本指令的主序列翻译之后才更新正式状态。随后执行翻译。当该重新翻译过程中出现意外事件时，可立即使用正式目标寄存器和存储器的正确目标状态来执行意外事件。

In summary：

             add   R0，Rebp，0×c

             ld    Recx，[R0]

             add   R2，Rebp，0×8

             ld    Reax，[R2]

             st    [Reax]，Recx

             add   Reax，Reax，4

             st    [R2]，Reax

             add   R7，Rebp，0×10

             ld    Reax，[R7]                                    // Live out

             sub   Recx，Reax，1                                 // Live out

             st    [R7]，Recx

             andcc R11，Reax，Reax

             add   Rseq，Reip，Length(block)

             ldc   Rtarg，EIP(target)

             selcc Reip，Rseq，Rtarg

             jg    mainlocp，mainloop
The comment“Live Out”refers to the need to actually maintain Reax
and Recx ccrrectly prior to the commit. Otherwise further
optimization might be possible.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

上述总结示出了优化过程中处于该位置时保留的主基本指令序列。虽然本实例示出了目标指令指针(EIP)顺列的维护，但是也可以使翻译时转移的指针EIP保持不顺列，这将省去实例中本步骤和后续步骤中更新序列的指针EIP。

    Renaming to reduce register resource dependencies.This will allow subsequent

    scheduling to be more effective.From this point on，the original target X86 code is

    omitted as the relationship between individual target X86 instructions and host

    instructions becomes increasingly blurred.

                   add   R0，Rebp，0×c

                   ld    R1，[R0]

                   add   R2，Rebp，0×8

                   ld    R3，[R2]

                   st    [R3]，R1

                   add   R4，R3，4

                   st    [R2]，R4

                   add   R7，Rebp，0×10

                   ld    Reax，[R7]                                // Live out

                   sub   Recx，Reax，1                             // Live out

                   st    [R7]，Recx

                   andcc R11，Reax，Reax

                   add   Rseq，Reip，Length(block)

                   ldc   Rtarg，EIP(target)

                   selcc Reip，Rseq，Rtarg

                   jg    mainloop，mainloop

本实例示出了通常称为寄存器更名的下一优化步骤，其中需要使用在主基本指令系列中用于多个操作的工作寄存器的操作改为采用不同的未使用工作寄存器以防止两条主指令要求使用同一硬件。因此，例如在上述两例中的第二条主基本指令使用了代表正式目标寄存器ECX的工作寄存器Recx。第十条主基本指令也使用工作寄存器Recx。通过改变第二主基本指令中的操作从而使R0内地址所指向的值存储在工作寄存器R1而不是寄存器Recx，两条主指令就不会使用同一寄存器。同样，第四、第五和第六条主基本指令在前面实例中都使用工作寄存器Reax；通过改变第四主基本指令为使用前面未使用的工作寄存器R3不是工作寄存器Reax以及使第六主基本指令使用前面未使用的工作寄存器R4而不是寄存器Reax，这就避免了对硬件使用的依赖性。

    After the scheduling process which organizes the primitive host operations as multiple

    operations that can execute in the parallel on the host VLIW hardware.Each line

    shows the parallel operations that the VLIW machine executes，and the“&amp;”indicates

    the parallelism.

                   add    R2，Rebp，0×8                               &amp; add R0，Rebp，0×c

                   nop                                                 &amp; add R7，Rebp，0×10

                   ld    R3，[R2]                                      &amp; add Rseq，Reip，Length(block)

                   ld    R1，[R0]                                      &amp; add R4，R3，4

                   st    [R3]，R1                                      &amp; ldc Rtarg，EIP(target)

                   ld    Reax，[R7]                                    &amp; nop

                   st    [R2]，R4                                      &amp; sub Recx，Reax，1

                   st    [R7]，Recx                                    &amp; andcc R11，Reax，Reax

                   selcc Reip，Rseq，Rtarg                             &amp; jg  mainloop，mainloop &amp; commit

    Host Instruction key：

         nop＝no operation

上述实例示出了在形态主机上执行的主基本指令的安排。在该实例中，假定形态主机为VLIW处理器，除了用于协调形态化软件的硬件增强部分以外，形态主机还包括其它处理单元中的两个算术和逻辑(ALU)单元。第一行表示两个单独的相加指令，它们已经安排在形态主机上一起运行。显而易见，在前述实例中它们是第三和第八条基本主指令。第二行包括NOP指令(无操作但是进入下一指令)和另一加法操作。NOP指令表示即使在经过某些安排优化之后也不一定是两条指令放在一起运行。在任何情况下，该实例示出了此时只剩下9组基本主指令来执行原先10条目标指令。

    Resolve host branch targets and chain stored translations

                   add   R2，Rebp，0×8              &amp; add R0，Rebp，0×c

                   nop                               &amp; add R7，Rebp，0×l0

                   ld    R3，[R2]                    &amp; add Rseq，Reip，Length(block)

                   ld    R1，[R0]                    &amp; add R4，R3，4

                   st    [R3]，R1                    &amp; ldc Rtarg，EIP(target)

                   ld    Reax，[R7]                  &amp; nop

                   st    [R2]，R4                    &amp; sub Recx，Reax，1

                   st    [R7]，Recx                  &amp; andcc R11，Reax，Reax

                   selcc Reip，Rseq，Rtarg           &amp; jg  Sequential，Target &amp; commit

本实例除了指令现在被存储于翻译缓冲器内并且执行一次以上(由于最后的跳转(jg)指令现在指向将另一翻译指令序列串接起来的跳转地址)以外基本上是同一组主基本指令。串接过程使指令序列跳出了翻译器主循环从而完成了序列的翻译。

    Advanced Optimizations，Backward Code Motion：

    This and subsequent examples start with the code prior to scheduling.

    This optimization first depends on detecting that the code is a loop.

    Then invariant operations can be moved out of the loop body and

    executed once before entering the loop body.

    entry：

               add   R0，Rebp，0×c

               add   R2，Rebp，0×8

               add   R7，Rebp，0×10

               add   Rseq，Reip，Length(block)

               ldc   Rtarg，EIP(target)

    Loop：

               ld    R1，[R0]

               ld    R3，[R2]

               st    [R3]，R1

               add   R4，R3，4
 
               st    [R2]，R4

               ld    Reax，[R7]

               sub   Recx，Reax，1
               st    [R7]，Recx
  
               andcc R11，Reax，Reax

               selcc Reip，Rseq，Rtarg

               jg    mainloop，Loop

上述实例示出了通常只与大量重复的序列一起使用的高级优化步骤。该进程首先检测构成循环的翻译，并检查单条基本主指令以确定循环体内哪条指令产生不变结果。这些指令从循环内去除并且只执行一次，将值放入寄存器内；从此，存储在寄存器内的值被重复使用而不是重新运行指令。

    Schedule the loop body after backward code motion.For example purposes，only

    the code in the loop body is shown scheduled

    Entry：

               add    R0，Rebp，0×c

               add    R2，Rebp，0×8

               add    R7，Rebp，0×10

               add    Rseq，Reip，Length(block)

               ldc    Rtarg，EIP(target)

    Loop：

               ld     R3，[R2]                      &amp; nop
               ld     R1，[R0]                      &amp; add R4，R3，4
 
               st     [R3]，R1                      &amp; nop

               ld     Reax，[R7]                    &amp; nop

               st     [R2]，R4                      &amp; sub Recx，Reax，1

当这些不重复的指令从循环中去除并且对序列进行安排之后，它们与上述实例中的指令相同。由此可见，在循环第一次迭代期间初始化指令被执行但是只执行一次，此后在循环期间只执行所示7个时钟间隔内剩余的主基本指令。这样执行时间从必须10条指令间隔缩短为7个指令间隔就能执行基本目标指令。

显而易见，从循环中去除的步骤是地址生成步骤。这样在改进型微处理器内只需在循环开始时生成一次地址；即，地址只需生成一次。另一方面，X86目标处理器的地址生成硬件必须在每次执行循环时生成地址。如果循环执行100次，则改进型微处理器只生成一次地址而目标处理器要生成100次的地址。

　　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   Rtarg，EIP(target)

　　Loop：

　　           ld    R1，[R0]

　　           ld    R3，[R2]

　　           st    [R3]，R1

　　           add   R4，R3，4

　　           st    [R2]，R4

　　           ld    Reax，[R7]                                      // Live out

　　           sub   Recx，Reax，1                                   // Live out

　　           st    [R7]，Recx

　　           andcc R11，Reax，Reax
    　　       selcc Reip，Rseq，Rtarg
　　
    　　       commit

　　　         jg    mainloop，Loop
				
				<dp n="d42"/>
Register Allocation：
This shows the use of register alias detection 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
freed.
Entry：

　　        add    R0，Rebp，0×c

　　        add    R2，Rebp，0×8

　　        add    R7，Rebp，0×10

　　        add    Rseq，Reip，Length(block)

  　　      ldc    Rtarg，EIP(target)
　
  　　      ld     Rc，[R0]               ；First do the load of the variable from
memory

　　        prot   [R0]，Alias1           ；Then protect the memory location from
stores

　　        ld     Rs，[R2]

　　        prot   [R2]，Alias2

　　        ld     Rn，[R7]

　　        prot   [R7]，Alias3
Loop：

　　        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，noAliasCheck

　　        andcc R11，Reax，Reax

　　        selcc Reip，Rseq，Rtarg

　　        commit

　　        jg    Epilog，Loop
Eoilog：

　　        FA    Alias1            Free the alias detection hardware

　　        FA    Alias2            Free the alias detection hardware

　　        FA    Alias3            Free the alias detection hardware

　　        j     Sequential
Host Instruction key：

　　  protect＝protect address from loads                FA＝free alias

　　  copy＝copy             j＝jump

本实例示出由本发明微处理器实现的更为高级的优化步骤。参见本实例前的第二个实例就会注意到涉及计算堆栈地址的前3条相加指令。这些地址在主操作序列执行期间不会变化。因此这些地址上存储的值可以从存储器内查找出来并载入寄存器以供立即使用。显而易见，在主基本指令6、8和10中都是这样做的。在指令7、9和11中，每个存储器地址被特殊的主别名硬件加上保护标记并且寄存器被表示为这些存储器地址的别名，所以如果试图改变数据就会引发意外事件。此时，每条涉及从堆栈存储器地址移动数据的加载操作都变为简单的寄存器之间的复制操作，这比从存储器地址加载数据要快许多。值得注意的是，一旦循环执行到n＝0，则必须去除每个存储器地址上的保护从而可以使用别名寄存器。

　　Copy Propagation：

　　After using the alias hardware to turn loads within the loop body

　　into copies，copy propagation allows the elimination of some copies.

　　Entry：

　　            add     R0，Rebp，0×c

　　            add     R2，Rebp，0×8

　　            add     R7，Rebp，0×10

　　            add     Rseq，Reip，Length(block)

　　            ldc     Rtarg，EIP(target)

　　            ld      Rc，[R0]

　　            prot    [R0]，Alias1

　　            ld      Rs，[R2]

　　            prot    [R2]，Alias2

　　            ld      Recx，[R7]

　　            prot    [R7]，Alias3

　　Loop：

　　            st      [Rs]，Rc
　　
    　　        add     Rs，Rs，4

　　            st      [R2]，Rs，NoAliasCheck

　　            copy    Reax，Recx                                 // Live out

　　            sub     Recx.Reax，1                               // Live out

　　            st      [R7]，Recx，NoAliascheck

　　            andcc   R11，Reax，Reax

　　            selcc   Reip，Rseq，Rtarg

　　            commit

　　            jg      Epilog.Loop

　　　Epilog：

　　            FA      Alias1

　　            FA      Alias2

　　            FA      Alias3

   　           j       Sequential

本实例示出了下一优化步骤，其中大多数代替上一实例中优化的加载指令的复制指令并非必要并且可以省略。即，如果进行寄存器之间的复制，则在复制数据的寄存器的操作前数据已经存在。如果是这样，可以在第一寄存器内访问数据而不是在复制数据的寄存器内，因此可以省略复制操作。显而易见，这省略了上一实例循环中所示的第一、第二、第五和第九基本主指令。此外，其它主基本指令中所用的寄存器也可以改为反映数据内容的正确的寄存器。这样，例如当省略第一和第二复制指令时，第三存储指令必须从实际存在数据的工作寄存器Rc(而不是寄存器R1)复制数据并放入实际存在地址的工作寄存器Rs(而非寄存器R3)指示的地址上。

　　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)

　　            ldc   Rtarg，EIP(target)

　　            ld    Rc，[R0]

　　            prot  [R0]，Alias1

　　            ld    Rs，[R2]

　　            prot  [R2]，Alias2

　　            ld    Recx，[R7]

　　            prot  [R7]，Alias3

　　Loop：

　　            st    [Rs]，Rc，                &amp; add Rs，Rs，4     &amp; copy

　　Reax，Recx

　　            st    [R2]，Rs，NAC             &amp; sub Recx，Reax，1

　　            st    [R7]，Recx，NAC           &amp; andcc R11，Reax，Reax

　　            selcc Reip，Rseq，Rtarg         &amp; jg  Epilog，Loop  &amp; commit
　　Epilog：
　
  　　          FA    Alias1
    　　        FA    Alias2
　　
    　　        FA    Alias3

　　            j     Sequential

　　Host Instruction key：

　　NAC＝No Alias Check

上述实例示出了安排后的主指令。将会看到，在执行该循环时，序列所需的时钟数要少于从源代码得到的基本目标指令所需的时钟数。因此除了所有其它加速技术以外，要运行的联合的操作的总数也少于执行源目标代码所需的操作数量。

Store Elimination by use of the alias hardware.
Entry：

　        add    R0，Rebp，0×c

          add    R2，Rebp，0×8

          add    R7，Rebp，0×10

          add    Rseq，Reip，Length(block)

          ldc    Rtarg，EIP(target)

          ld     Rc，[R0]

          prot   [R0]，Alias1                ；protect the address from loads
and stores

          ld     Rs，[R2]

          prot   [R2]，Alias2                ；protect the address from loads
and stores
          ld     Recx，[R7]

          prot   [R7]，Alias3                ；protect the address from loads
and stores
Loop：

          st     [Rs]，Rc，                  &amp; add Rs，Rs，4     &amp; copy
Reax，Recx

          sub    Recx，Reax，1               &amp; andcc R11，Reax，Reax

          selcc  Reip，Rseq，Rtarg           &amp; jg  Epilog，Loop  &amp; commit
Epilog：

          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

本实例所示的最后优化是使用别名硬件以节省存储。这节省了循环体内的存储并且只在循环结束部分施行。与最初10条目标指令相比，这将循环体内主指令的数量减少到3条。

虽然以上借助实施例描述了本发明，但是本领域内技术人员可以在不偏离本发明范围和精神的前提下对本发明作出各种修改和变动。例如虽然本发明描述的是X86处理器的仿真，但是它也可以应用于针对其它处理器结构设计的应用程序上，也可以用于运行在虚拟机上的程序，例如P code、Postscript或Java程序等。因此本发明由下面所附权利要求限定。

Claims

1.一种控制计算机内存储器访问的系统，其特征在于包含：

指示指令地址是否指向存储器或存储器映射的I/O设备的硬件装置；

初始化预测地址是存储器或I/O的指令的软件装置；

将指令作出的预测与硬件装置的指示比较的装置；以及

如果比较显示预测与指示不同则采取校正动作的装置。

2.如权利要求1所述的控制存储器访问的系统，其特征在于硬件装置包含：

后备缓冲器，包含多个虚拟地址和相关物理地址的存储单元；以及

翻译后备缓冲器的每个存储单元内的存储位置。

3.如权利要求1所述的控制存储器访问的系统，其特征在于初始化预测地址是存储器或I/O的指令的软件装置是从目标处理器的一组指令翻译为用于主处理器的一组指令，该组指令包括指令所用每个地址的预测指示。

4.如权利要求1所述的控制存储器访问的系统，其特征在于硬件装置包含：

翻译后备缓冲器的每个存储单元内的存储位置；

初始化预测地址是存储器或I/O的指令的软件装置是从目标处理器的一组指令翻译为用于主处理器的一组指令，该组指令包括指令所用每个地址的预测指示。

5.如权利要求4所述的控制存储器访问的系统，其特征在于将指令作出的预测与硬件装置的指示比较的装置包含硬件比较器，用于将每个地址的预测指示与存储匹配地址的存储单元内存储位置条件进行比较。

6.一种用于微处理器的存储控制器，其特征在于包含：

检测对被寻址存储器性质预测失败的装置；以及

从这种失败中恢复的装置。

7.如权利要求6所述的存储控制器，其特征在于检测对被寻址存储器性质预测失败的装置包含：

存储被寻址物理存储器性质指示的硬件装置；以及

将被寻址存储器性质的预测与硬件装置存储的被寻址物理存储器性质指示进行比较的装置。

8.如权利要求7所述的存储控制器，其特征在于从这种失败中恢复的装置包含：

响应将被寻址存储器性质的预测与硬件装置存储的被寻址物理存储器性质指示进行比较的装置作出的比较失败以生成意外事件的装置；以及

响应意外事件的装置。

9.如权利要求6所述的存储控制器，其特征在于检测被寻址存储器性质预测失败的装置包含：

存储被寻址物理存储器性质指示的硬件装置；以及

将被寻址存储器性质的预测与硬件装置存储的被寻址物理存储器性质指示进行比较的装置；

从这种失败中恢复的装置包含：

响应意外事件的装置。

10.如权利要求9所述的存储控制器，其特征在于响应意外事件的装置包括：

利用微处理器恢复计算机状态的装置；以及

如果被寻址存储器性质与预测不相同时访问地址的装置。

11.如权利要求所述的存储控制器，其特征在于从这种失败恢复的装置包含：

生成意外事件以响应被寻址存储器性质预测失效的装置；

提供进程以从与被寻址存储器性质的预测失败相关的意外事件中恢复的装置。

12.一种用于计算机的存储控制系统，其特征在于包含：

主存储器；

存储器映射输入/输出(I/O)设备；

使命令作用于特定地址上操作的存储控制软件；

翻译后备缓冲器，包括用于存储最近被访问的虚拟地址和这些虚拟地址至计算机内物理地址的翻译结果的存储单元；

至少一个用于记录地址是假定为存储器还是存储器映射I/O的指示的每个存储单元的存储位置。

13.如权利要求12所述的存储控制系统，其特征在于进一步包含访问翻译后备缓冲器内存储的虚拟地址的指令是否假设物理地址与记录的物理地址指示一致。

14.一种从有关作为计算机系统内存储器被访问单元性质的失败预测恢复的方法，其特征在于包含以下步骤：

提供从与作为存储器被访问的单元性质存在性失败的意外事件中恢复的进程；

生成对预测特定地址性质的地址的访问；

通过将该预测与被寻址单元的性质比较而检测预测的失败；以及

通过运行进程而响应预测失败的检测。

15.如权利要求14所述的从预测失败恢复的方法，其特征在于检测预测失败的步骤包括产生意外事件以响应预测失败的步骤。

16.如权利要求14所述从失败预测中恢复的方法，其特征在于：

提供从与作为存储器被寻址的单元性质存在性失败的意外事件中恢复的进程的步骤包括：

存储将计算机系统状态的指示恢复至预测之前的意外事件处理器；以及

存储预测之前存在的计算机系统状态的指示。

通过运行进程响应预测失败的检测的步骤包括：

恢复存储的状态指示；以及

利用从发生失败预测之处恢复的状态继续操作计算机。

17.一种微处理器，其特征在于包含：

能够执行第一指令集的主处理器；

将为具有第二不同指令集的目标处理器而编写的程序翻译为第一指令集的代码形态软件；以及

存储控制器，它包括：

包含多个存储单元的地址翻译缓冲器，在存储单元内记录了最近被访问的虚拟目标地址和虚拟目标地址表示的物理地址，

每个存储单元包含指示物理地址是存储器地址还是存储器映射输入/输出(I/O)地址的装置；以及

将存储单元内的指示与所作的对存储单元内虚拟目标地址的访问是存储器或存储器映射I/O的预测进行比较以指示访问地址中所进行的下一操作的装置。

18.如权利要求17所述的微处理器，其特征在于将存储单元内的指示与所作的对存储单元内虚拟目标地址的访问是存储器或存储器映射I/O的预测进行比较以指示访问该地址中所进行的下一操作的装置包含：

生成意外事件以响应比较失败的装置；以及

响应意外事件以指示访问该地址中所进行的下一操作。

19.如权利要求18所述的微处理器，其特征在于指示物理地址是存储器地址还是存储器映射输入/输出(I/O)地址的装置包含存储单元内的存储位置。

20.一种存储控制器，其特征在于包括：

包含多个存储单元的地址翻译缓冲器，在存储单元内记录了最近被访问的虚拟地址和由虚拟地址表示的物理地址，

将存储单元内的指示与所作的对存储单元内虚拟目标地址的访问是存储器或存储器映射I/O的预测进行比较以指示访问该地址中所进行的下一操作的装置。

21.如权利要求20所述的微处理器，其特征在于将存储单元内的指示与所作的对存储单元内虚拟目标地址的访问是存储器或存储器映射I/O的预测进行比较以指示访问该地址中所进行的下一操作的装置包含：

生成意外事件以响应比较失败的装置；以及

响应意外事件以指示访问该地址中所进行的下一操作。

22.如权利要求18所述的微处理器，其特征在于指示物理地址是存储器地址还是存储器映射输入/输出(I/O)地址的装置包含存储单元内的存储位置。