CN1434938A

CN1434938A - 重启动翻译的指令

Info

Publication number: CN1434938A
Application number: CN01810818A
Authority: CN
Inventors: E·C·内维尔; A·C·罗斯
Original assignee: Advanced Risc Machines Ltd
Current assignee: ARM Ltd
Priority date: 2000-10-05
Filing date: 2001-06-21
Publication date: 2003-08-06
Anticipated expiration: 2021-06-21
Also published as: US20020066003A1; JP2004511041A; MY127147A; KR20030034243A; GB0024402D0; CN1287270C; IL151396A0; WO2002029555A1; US7003652B2; EP1323032B1; IL151396A; GB2367653A; GB2367653B; EP1323032A1; JP4950408B2; RU2002127807A; RU2263949C2; DE60140068D1; KR100890243B1; TWI224280B

Abstract

一处理系统，具有执行第一指令集的指令的一处理器内核(104)以及用于生成与第一指令集的一个或多个指令一致的翻译器输出信号的指令翻译器(108)以便仿真第二指令集的指令。指令翻译器(108)提供指定操作的翻译器输出信号，该操作被分配以便对第二指令集的一个指令的输入变量直到仿真那个指令的最后操作被执行才被改变。在执行第一指令集的指令的一个操作后一中断处理器提供中断服务。分配翻译的指令序列以便输入状态直到执行最后的指令才会改变具有在中断后如果当中断发生时最后操作还未开始，则可通过重新运行整个仿真，或如果当中断发生时最后操作已经开始则通过运行来自第二指令集的下一指令重启动处理的结果。

Description

重启动翻译的指令

本发明领域数据处理系统领域。更准确地说，本发明涉及具有用来执行第一指令集的指令的一处理器内核以及可用来将第二指令集的指令翻译成适于由该处理器内核执行的一种形式的一指令翻译器的数据处理系统。

提供能结合具有一本机指令集的一处理器内核操作来将非本机指令翻译成由处理器内核执行的本机指令的指令翻译器是公知的。虽然这种方法在扩展一数据处理系统的能力方面是很有吸引力的，但它也带来某些困难和复杂性。

一个这样的问题是如何处理中断信号。需要一种能尽可能快速地响应中断信号的处理系统。这在控制实时操作的系统中特别重要。中断等待时间能是一临界特性参数并可使用最糟糕的情形来测量。因此，当执行本机指令时，基于当前正在执行本机指令的完成安排响应一中断信号是公知的。

在一系统环境中，其中非本机指令将被翻译成本机指令，它通常发生一单个非本机指令可被翻译成多个本机指令。因此，如果在执行表示一单个非本机指令的本机指令序列期间接收到一中断，那么该非本机指令可仅部分地完成且该处理系统的状态可是不确定的。解决这种问题的一个方法是提供在接收到一中断信号的基础上被启动的另外的硬件来存储该处理系统的当前状态以便在重启动前中断后该状态被恢复，因此任何部分完成的非本机指令能被提前完成。然而，这种方法具有导致另外的硬件开销、重大的另外的复杂性以及由于需要在提供中断服务前保存该处理系统的状态，从而降低其自身的中断性能的缺点。

另一方法是控制该系统以便非本机指令可被作为最小单元(atomic)，即直到一非本机指令完全完成其执行后才会提供中断服务。该方法又与中断等待时间冲突。

用于指令集间的翻译的已知系统的例子和其他背景信息可在以下中发现：US-A-5,805,895；US-A-3,955,180；US-A-5,970,242；US-A-5,619,665；US-A-5,826,089；US-A-5,925,123；US-A-5,875,336；US-A-5,937,193；US-A-5,953,520；US-A-6,021,469；US-A-5,568,646；US-A-5,758,115；US-A-5,367,685；IBM技术公开布告板，March1988，pp308-309，“用于精简指令集计算机的系统/370模拟器辅助处理器”(IBM Technical Disclosure Bulletin，March 1988，pp308-309，“System/370 Emulator Assist Processor For a ReducedInstruction Set Computer”)；IBM技术公开布告板，March1988，pp548-549，“全功能系列/1指令集模拟器”(IBM TechnicalDisclosure Bulletin，July 1986，pp548-549，“Full Function Series/1 Instruction Set Emulator”)；IBM技术公开布告板，March1994，pp605-606，“在RISC处理器上的实时CISC结构HW模拟器”(IBMTechnical Disclosure Bulletin，March 1994，pp605-606，“Real-TimeCISC Architecture HW Emulator ON A RISC Processor”)；IBM技术公开布告板，March 1998，p272，“使用模拟控制块的性能改进”(IBMTechnical Disclosure Bulletin，March 1998，p272，“PerformanceImprovement Using an Emulation Control Block”)；IBM技术公开布告板，January 1995，pp537-540，“用于精简指令集计算机/循环系统模拟的快速指令解码”(IBM Technical DisclosureBulletin，January 1995，pp537-540，“Fast Instruction Decode ForEmulat ion on Reduced Instruction Set Computer/Cycles System”)；IBM技术公开布告板，February 1993，pp231-234，“高性能双结构处理器”(IBM Technical Disclosure Bulletin，February1993，pp231-234，“High performance Dual ArchitectureProcessor)”；IBM技术公开布告板，August 1989，pp40-43，“系统370I/O通道程序命令字预取”(IBM Technical DisclosureBulletin，August 1989，pp40-43，“System/370 I/O Channel ProgramChannel Command Word Prefetch”)；IBM技术公开布告板，June 19851988，pp305-306，“全微码控制结构”(IBM Technical DisclosureBulletin，June 1985 1988，pp305-306，“Fully Microcode-ControlledEmulation Architecture”)；IBM技术公开布告板，March1972，pp3074-3076，“模拟的操作码和状态处理”(IBM TechnicalDisclosure Bulletin，March 1972，pp3074-3076，“Op Code and StatusHandling For Emulation”)；IBM技术公开布告板，August1982，pp954-956，“带有大系统最常使用的指令和适于码保持指令的微处理器的芯片上微码”(IBM Technical Disclosure Bulletin，August1982，pp954-956，“On-Chip Microcoding of a Microprocessor WithMost Frequently Used Instruction of Large System and PrimitivesSuitable for Coding Remaining Instructions”)；IBM技术公开布告板，April 1983，pp5576-5577，“模拟指令”(IBM TechnicalDisclosure Bulletin，April 1983，pp5576-5577，“EmulationInstruction”)；系统结构(the book ARM System Architecture byS Furber)；计算机结构：大量方案(the book Computer Architecture：AQuantitative Approach by Hennessy and Patterson)；和JAVA虚拟机标准(the book The Java Virtual Machine Specification by TimLindholm and Frank Yellin 1^st and 2^st Editions)。

如果有人认为有人希望在实时应用如气囊控制系统或防锁制动系统中使用这种系统时，则当执行非本机指令时实现低中断等待时间的需要是很突出的，其中最坏情况下中断等待时间可能是一安全的临界参数。

从一个方面可以看到，本发明提供用于处理数据的装置，所述装置包括：

一处理器内核，用来执行由第一指令集的指令指定的操作；

一指令翻译器，用来将第二指令集的指令翻译成与所述第一指令集的指令一致的翻译器输出信号，使用一个或多个输入变量，所述第二指令集的至少一个指令指定将被执行的操作；

一中断处理器，响应一中断信号，在完成一当前正在执行的操作的执行后，中断与所述第一指令集的指令一致的操作的执行；以及

重启动逻辑，用于在所述中断后重启动执行；其中

所述指令翻译器用来生成与所述第一指令集的指令一致的一组或多组翻译器输出信号序列以表示所述第二指令集的所述至少一个指令，每个序列是直到在所述序列中的最后操作被执行才改变所述一个或多个输入变量；以及

在执行表示所述第二指令集的所述至少一个指令的操作序列间发生一中断后：

(i)如果在开始执行所述序列中的最后一个操作前发生所述中断，那么所述重启动逻辑在所述序列中第一操作重启动执行；以及

(ii)如果在开始执行所述序列中的最后一个操作后发生所述中断，那么所述重启动逻辑在所述序列后的下一指令重启动执行。

本发明允许将非本机指令翻译成可采取几种等效的本机指令来执行以及在完成与一本机指令一致的一操作后提供中断服务而不会在重启动上引入过分的困难的一种方式。本发明通过安排翻译的操作序列不对用于那个操作的输入变量做任何改变直到最后操作被执行为来实现上述目的。因此，如果发生的中断先于执行最后操作，那么非本机指令能被整个地重启动同时输入变量将不变，而如果发生的中断在开始最后操作的执行后，那么在该发生的中断期间最后操作将完成以及重启动逻辑能从该非本机指令后的下一指令继续。

应当理解来自第二(非本机)指令集的指令可被完全翻译成第一(本机)指令集的指令。然而，也可能来自第二指令集的指令可翻译成能用与来自第一指令集的指令相同的方式控制处理器内核的控制信号的形式。另外的可能性是来自第二指令集的指令可具有超过来自第一指令集的指令的能力以及从第二指令集的指令推导出来的控制信号可控制处理器内核的操作，在某种意义上超出由第一指令集的指令提供的功能。

应当理解重启动逻辑可是一种专用的硬件产品，在本发明的优选实施例中，重启动逻辑可是指令翻译器的一部分。指令翻译器生成控制为非本机指令提供的操作序列的翻译器输出信号以及可容易地确定当中断发生时是否已经开始最后操作。该信息因此可容易地提供给指令翻译器中的重启动逻辑以便确定是非本机指令整个重启动还是重启动下一指令。

如果的确发生一中断，了解该系统应当如何被重启动的一方便的方法是将一指针存储到一重启动单元同时该指针基于最后操作的执行向前移。该指针可适于指向存储当前正被翻译的一指令的一存储单元的一存储地址的一程序计数值。

同时本发明也可用于许多不同类型的指令集，当第二指令集基于保存在一堆栈中的堆栈操作码是指定将被执行的一个操作时则特别有用。这种基于系统的堆栈通常从该堆栈读取它们的输入操作码以及将它们的输出操作码写入该堆栈中。当仿真这种操作时，本发明确保堆栈操作码不被重写直到执行最后操作已经开始后为止。用相同的方式，直到执行最后操作开始堆栈操作码才被添加到堆栈中。

应当理解，控制一特定的非本机指令如何执行的系统的输入变量可超过在那个非本机指令中的设定地公开的操作码。尤其，周围的系统状态变量可影响一指定的指令如何执行，因此，本发明提供直到最后操作执行开始以后才改变此类系统状态变量。

确保系统状态直到最后操作执行才被改变的需要在生成有效的翻译操作序列上可能是一种约束。因此，中断等待时间可被保存，可影响非本机指令的处理速度。然而，这种效果在系统中可被降低，其中基于处理器内核的寄存器通过提供保存在处理器内核的寄存器中的堆栈操作码被映射到与一映射状态一致的堆栈位置正在仿真基于指令的堆栈，该映射状态直到最后操作被执行才被更新，以便输入操作码不会被移出该堆栈以及输出操作码不被添加到该堆栈中直到最后操作为止，而不会强加太多的约束到可被翻译的或可获得的指令类型或翻译序列的紧密度上。

从另一方面来看，本发明提供处理数据的一种方法，所述方法包括步骤：

执行由第一指令集的指令指定的操作；

将第二指令集的指令翻译成与所述第一指令集的指令一致的翻译器输出信号，使用一个或多个输入变量，所述第二指令集的至少一个指令指定将被执行的操作；

响应一中断信号，在完成一当前正在执行的操作的执行后，中断与所述第一指令集的指令一致的操作的执行；以及

在所述中断后重启动执行；其中

所述翻译步骤生成与所述第一指令集的指令一致的一组或多组翻译器输出信号序列以表示所述第二指令集的所述至少一个指令，每个序列是直到在所述序列中的最后操作被执行才改变所述一个或多个输入变量；以及

在执行表示所述第二指令集的所述至少一个指令的操作序列间发生中断后：

(ii)如果在开始执行所述序列中的最后一个操作后发生所述中断，那么所述重启动逻辑在所述序列后的一下一指令重启动执行。

本发明也提供具有根据上述技术能控制通用计算机的计算机程序的计算机程序产品。

本发明的实施例将仅通过例子，参考附图来说明，其中：

图1和2示意性地表示示例性的指令流水线装置；

图3更详细地说明一读取阶段装置；

图4示意性地说明从该提取阶段中缓冲指令字中读取可变长度的非本机指令；

图5示意性地说明用于执行处理器内核本机指令以及要求翻译的指令的一数据处理系统；

图6示意性地说明用于示例性指令序列以及说明用于堆栈操作码存储的寄存器内容、映射状态以及要求翻译的指令与本机指令间的关系；

图7示意性地说明作为本机指令序列的一非本机指令的执行；

图8是说明指令翻译器可用保存用于翻译的指令的中断等待时间的方式操作的方法的流程图；

图9示意性地说明使用硬件和软件技术将Java字节码翻译成ARM操作码；

图10示意性地说明基于翻译器的一硬件、基于翻译程序的一软件以及基于调度的一软件间的控制的流程；

图11和12说明使用基于方法的一定时器控制调度操作的另一种方法；以及

图13是说明控制图12的电路的操作的信号的信号图。

图1示出了适于用在基于系统的ARM处理器中的第一个示例性的指令流水线30的一种类型。该指令流水线30包括一读取阶段32、一本机指令(ARM/Thumb指令)译码阶段34、一执行阶段36、一存储器存取阶段38以及一回写阶段40。该执行阶段36、存储器存取阶段38以及回写阶段40基本上是常规的。读取阶段32的下游以及本机指令译码阶段34的上游，具有一指令翻译器阶段42。该指令翻译器阶段42是将一可变长度的Java字节码指令翻译成本机ARM指令的一有限态机器。该指令翻译器阶段42能多步操作由此一单个Java字节码指令能生成沿剩余的指令流水线30馈送的ARM指令序列来执行由Java字节码指令指定的操作。简单的Java字节码指令可仅要求一单个的ARM指令来执行它们的操作，而更复杂的Java字节码指令或在周围系统状态专用环境中，需要几个ARM指令来提供由Java字节码指令指定的操作。该多步操作发生在读取阶段32的下游，因此，基于从一存储器系统取多个翻译的ARM指令或Java字节码电力不会消耗。Java字节码指令用常规的方式被存储在存储器系统中以便不对存储器系统提出另外的约束从而支持Java字节码翻译操作。

如上所述，指令翻译器阶段42具有一分路器通路。当不在一指令翻译模式中操作时，指令流水线30可绕过指令翻译器阶段42并用基本上不变的方式操作来提供译码本机指令。

在指令流水线30中，指令翻译器阶段42被描述成生成完全表示相应的ARM指令的翻译器输出信号并通过多路复用器被传递到本机指令译码器34。指令翻译器42也生成可被传递给本机指令译码器34的一些附加的控制信号。在该本机指令编码中的位空间约束可将限制强加于由本机指令提定的操作码的范围上。这些限制不必由非本机指令共享。附加的控制信号被提供以传递从非本机指令推导出的另外的指令指定信号，所述非本机指令不可能在存储在存储器中的本机指定中指定。例如，本机指令可仅提供相对低的多位用作本机指令中的立即操作数字段，而非本机指令可允许扩充的范围并且这可通过使用另外的控制信号向翻译的本机指令的本机指令译码器外面传送立即操作数的扩充部分被采用，翻译的本机指令也可被传递给本机指令译码器34。

图2描述一另外指令流水线44。在该例子中，该系统具有两个本机指令译码器46、48以及一非本机指令译码器50。非本机指令译码器50在操作中被约束，该操作可由被提供来支持本机指令的执行阶段52、存储器阶段54以及回写阶段56指定。因此，非本机指令译码器50必须有效地将非本机指令翻译成本机操作(其可是单个的本机操作或本机操作序列)，然后，向执行阶段52提供适当的控制信号来执行一个或多个本机操作。应当理解，在该例子中，该非本机指令译码器不产生形成一本机指令的信号，而是提供指定本机指令(或扩展的本机指令)操作的控制信号。生成的控制信号可与本机指令译码器46、48生成的控制信号不匹配。

在操作中，由读取阶段58提取的一指令根据特定的处理模式使用所述的信号分离器被有选择地提供给指令译码器46、48或50中的一个。

图3示意性地详细描述一指令流水线的读取阶段。取指逻辑60从一存储器系统提取固定长度指令字并将这些提供给一指令字缓冲器62。该指令字缓冲器62是一个具有两个端的摇摆缓冲器以便它可存储一当前指令字和一下一指令字。无论何时当前指令字已经被完全译码以及编码已经加在下一指令字上，然后取指逻辑60用来将从存储器中提取的下一指令字代替前一个当前指令字，即，摆动缓冲器的每一端将以一种交叉存取的方法以2递增连续存储的指令字。

在所描述的例子中，一Java字节码指令最大的指令长度是三字节。因此，提供三个多路复用器允许字缓冲器62的任一端的任何三个相邻字节被选择并提供给指令翻译器64。字缓冲器62以及指令翻译器64也具有一旁路通路(bypass path)，用在提取并被译码本机指令时。

将会看到，每个指令字被从存储器提取一次并存储在字缓冲器62中。一单个的指令字可具有从其读出的多个Java字节码同时指令翻译器64执行将Java字节码翻译成ARM指令。可变长度的本机指令翻译序列可被生成而不要求多个存储器系统读取以及不浪费存储器资源或将其他约束强加于存储器系统同时指令翻译操作可被限制在指令流水线中。

一程序计数值与当前正被翻译的每个Java字节码有关。该程序计数值沿流水线阶段被传递以便每个阶段能，如果必要的话，使用与它正在处理的特定的Java字节码有关的信息。用于翻译成多个ARM指令操作序列的一Java字节码的该程序计数值不会递增直到在那个序列中的最后的ARM指令操作开始被执行为止。用继续直接指向存储器中的正在被执行的指令的方式保持该程序计数值简化该系统的其他方面，如调试以及分支目标计算。

图4示意性地描述从指令缓冲器62读取可变长度Java字节码指令。在第一阶段，具有一个长度的一Java字节码指令被读取并被译码。下一阶段是三个字节长度以及跨距已经从存储器提取的相邻指令字间的一Java字节码指令。这些指令字均出现在指令缓冲器62中因而指令译码和处理不会被所提取的指令字间的一可变长度指令的跨距而延迟。只要已经从指令缓冲器62读出三个Java字节码，先前提取的指令字的替换物(refill)可开始同时后续处理将从已经出现的下一指令字继续译码Java字节码。

图4中描述的最后阶段描述了正被读取的第二三字节码指令。这再次跨越两个指令字间。如果在前的指令字还没有完成其替换，那么读取的指令可被一流水线停顿延迟直到适当的指令字已经被存储在指令缓冲器62中为止。在某些实施例中，计时可由于行为类型，流水线永不停顿。应当理解，特殊的例子是相对的偶尔发生的例子同时大多数Java字节码比所描述的例子短，因此均跨越指令字间的两个连续编码相对来说是不寻常的。有效信号可用能用信号表示在从其读出一Java字节码前该指令字是否被适当地替换的方式与指令缓冲器62中的每个指令字相关联。

图5表示包括一处理器内核104和一寄存体106的数据处理系统102。在指令通路中提供一指令翻译器108以便将Java虚拟机器指令翻译成本机ARM指令(或与其相应的控制信号)，然后将其提供给处理器内核104。当本机ARM指令正被从可寻址的存储器中提取时可绕过指令翻译器108。可寻址存储器可是一存储器系统，诸如具有另外的片外的RAM存储器的高速缓存存储器。在存储器系统，特别是高速缓存存储器的下游提供指令翻译器108允许高效使用存储器系统的存储容量，因为要求翻译的紧密指令可被存储在该存储器系统中并在被传送给处理器内核104前仅立即被扩展为本机指令。

在该例子中寄存体106包含十六个通用32位寄存器，在它们中，有四个被分配用于存储堆栈操作码，即，用于存储堆栈操作码的寄存器组是寄存器R0、R1、R2以及R3。

寄存器组可是空的、部分填充堆栈操作码或完全填充堆栈操作码。当前保存堆栈操作码的顶端的特定的寄存器可是寄存器组中的任何一个寄存器。因此，应当理解指令翻译器可在当所有寄存器为空时的一个状态以及四组的四个状态一致的十七个不同映射状态的任何一个中，四组的四个状态的每一个与保存在寄存器组中的各个不同的若干堆栈操作码一致并具有保存堆栈操作码的顶端的一个不同的寄存器。表1表示用于指令翻译器108的该状态映射的十七种不同的状态。应当理解为堆栈操作码存储所分配的不同的若干寄存器，或由于特定存储器内核具有的约束，它能处理存储在寄存器中的数据值，映射状态可非常依赖于特定的实现以及Tabel1仅作为一个特定实现的例子。

状态0000

R0＝EMPTY

R1＝EMPTY

R2＝EMPTY

R3＝EMPTY

状态00100 状态01000 状态01100 状态10000

R0＝TOS R0＝TOS R0＝TOS R0＝TOS

R1＝EMPTY R1＝EMPTY R1＝EMPTY R1＝TOS

R2＝EMPTY R2＝EMPTY R2＝TOS-2 R2＝TOS-2

R3＝EMPTY R3＝TOS-1 R3＝TOS-1 R3＝TOS-1

状态00101 状态01001 状态01101 状态10001

R0＝EMPTY R0＝TOS-1 R0＝TOS-1 R0＝TOS-1

R1＝TOS R1＝TOS R1＝TOS R1＝TOS

R2＝EMPTY R2＝EMPTY R2＝EMPTY R2＝TOS-3

R3＝EMPTY R3＝EMPTY R3＝TOS-2 R3＝TOS-2

状态00110 状态01010 状态01110 状态10010

R0＝EMPTY R0＝EMPTY R0＝TOS-2 R0＝TOS-2

R1＝EMPTY R1＝TOS-1 R1＝TOS-1 R1＝TOS-1

R2＝TOS R2＝TOS R2＝TOS R2＝TOS

R3＝EMPTY R3＝EMPTY R3＝EMPTY R3＝TOS-3

状态00111 状态01011 状态01111 状态10011

R0＝EMPPTY R0＝EMPTY R0＝EMPTY R0＝TOS-3

R1＝EMPTY R1＝EMPTY R1＝TOS-2 R1＝TOS-2

R2＝EMPTY R2＝TOS-1 R2＝TOS-1 R2＝TOS-2

R3＝TOS R3＝TOS R3＝TOS R3＝TOS

表1

在表1中，可以看到前三位状态值表示寄存器组中非空寄存器的数量。后两位状态值表示保存堆栈操作码的顶端的寄存器号。这样，该状态值可被轻易用来控制一硬件翻译器或一软件翻译程序的操作来考虑当前占用的寄存器组以及堆栈操作码的顶端的当前位置。

如图5中所示，Java字节码J1、J2、J3流从可寻址存储器系统被送入指令翻译器108。然后指令翻译器108根据该输入的Java字节码以及该指令翻译器8的瞬时映射状态以及其他变量输出ARM指令流(或等效的控制信号，或者扩展)。所描述的例子表示Java字节码J1可被映射成ARM指令A¹1和A¹2。Java字节码J2映射成ARM指令A²1、A²2以及A²3。最后，Java字节码J3映射成ARM指令A³1。每个Java字节码可要求一个或多个堆栈操作码作为输入以及可产生一个或多个堆栈操作码作为一输出。假定在该例子中处理器内核104是具有一载入/存储结构的一ARM处理器内核，由此仅保存在寄存器中的数据值可被处理，指令翻译器108被安排来生成ARM指令，按照需要，将所需的堆栈操作码在它们被处理前装入寄存器组或存储到寄存器组中任何保存堆栈操作码的可寻址存储器以便为可被生成的最后堆栈操作码腾位。应当理解，每个Java字节码可被认为具有表示堆栈操作码的数量的一个相关的“要求满(require full)”值，这些操作码在其执行前必须出现在寄存器组中以及表示寄存器组中空寄存器数量的一个“要求空(require empty)”值，这些寄存器在执行表示Java操作码的ARM指令执行前必须有效。

表2描述最初映射状态值，要求满值、最后状态值以及相关的ARM指令间的关系。最初状态值以及最后状态值与表1中描述的映射状态一致。指令翻译器108确定与它正在翻译的特定Java字节码(操作码)有关的一要求满值。指令翻译器108，根据它的最初映射状态，确定多个堆栈操作码是否需要在执行Java字节码前载入寄存器组。表1示出了使用相关的ARM指令(LDR指令)和如在堆栈高速缓存载入操作后将被采用的最后映射状态来确定堆栈操作码是否需要被载入寄存器组中最初状态以及应用到Java字节码的要求满值的测试和最后映射状态。实际上，如果不至一个堆栈操作码需要在执行Java字节码前被载入寄存器组，那么多个映射状态翻译将会发生，每个具有一相关的ARM指令，ARM指令将堆栈操作码载入寄存器组的一个寄存器中。在不同的实施例中，可能在一单个状态翻译中载入多个堆栈操作码并因此使映射状态改变超过表2中所示以外。最初状态要求满最后状态动作

00000 ＞0 00100 LDR R0，[Rstack，#-4]！

00100 ＞1 01000 LDR R3，[Rstack，#-4]！

01001 ＞2 01101 LDR R3，[Rstack，#-4]！

01110 ＞3 10010 LDR R3，[Rstack，#-4]！

01111 ＞3 10011 LDR R0，[Rstack，#-4]！

01100 ＞3 10000 LDR R1，[Rstack，#-4]！

01101 ＞3 10001 LDR R2，[Rstack，#-4]！

01010 ＞2 01110 LDR R0，[Rstack，#-4]！

01011 ＞2 01111 LDR R1，[Rstack，#-4]！

01000 ＞2 01100 LDR R2，[Rstack，#-4]！

00110 ＞1 01010 LDR R1，[Rstack，#-4]！

00111 ＞1 01011 LDR R2，[Rstack，#-4]！

00101 ＞1 01001 LDR R0，[Rstack，#-4]！

表2

从表2可以看出，载入存储堆栈操作码的寄存器组中的一新的堆栈操作码将形成堆栈操作码的新的顶端以及根据最初状态将被载入寄存器组中的特定的一个寄存器。

表3用相同的方法表示最初状态、要求空值、最后状态以及相关的ARM指令的关系，该ARM指令用于清空寄存器组中的一个寄存器以便如果一特定的Java字节码的要求空值表示有必要在Java字节码执行前给出该最初状态，在最初状态和最后状态间移动。存储于具有一STR指令的可寻址存储器的该特定的寄存器值将随哪一寄存器是堆栈操作码的当前的顶端而改变。

起始状态要求空最后状态动作

00100 ＞3 00000 STR R0[Rstack]，#4

01001 ＞2 00101 STR R0[Rstack]，#4

01110 ＞1 01010 STR R0[Rstack]，#4

10011 ＞0 01111 STR R0[Rstack]，#4

10000 ＞0 01100 STR R1[Rstack]，#4

10001 ＞0 01101 STR R2[Rstack]，#4

10010 ＞0 01110 STR R3[Rstack]，#4

01111 ＞1 01011 STR R1[Rstack]，#4

01100 ＞1 01000 STR R2[Rstack]，#4

01101 ＞1 01001 STR R3[Rstack]，#4

01010 ＞2 00110 STR R1[Rstack]，#4

01011 ＞2 00111 STR R2[Rstack]，#4

01000 ＞2 00100 STR R3[Rstack]，#4

00110 ＞3 00000 STR R2[Rstack]，#4

00111 ＞3 00000 STR R3[Rstack]，#4

00101 ＞3 00000 STR R1[Rstack]，#4

表3

应当理解在上面描述的典型的系统中，要求满和要求空状态是相互排斥的，即在任何结定时间对一特定的Java字节码来说只有要求满或要求空要求中的一个是真的，该Java字节码是指令翻译器正试图翻译的。指令翻译器108使用的指令模板以及被选择来支持硬件指令翻译器108的指令被选择以便可满足相互排斥的要求。如果该要求不适当，那么该情形可出现，其中要求大量输入堆栈操作码出现在寄存器组中的一特定的Java字节码不允许在执行表示该Java字节码的指令后足够的空寄存器是有效的以允许执行结果被存储在所要求的寄存器中。

应当理解一给定的Java字节码将具有表示用掉的堆栈操作码的数量和在执行那个Java操作码的基础上生成的堆栈操作码的数量间的差值的一总的基本的堆栈动作。由于用掉的堆栈操作码的数量是在执行前的一个必要条件以及生成的堆栈操作码是执行后的一个必要条件，与每个Java字节码有关的要求满以及要求空值必须在那个字节码执行前被满足，即使基本的总动作本身是被满足的。表4描述一最初状态、一整体堆栈动作、一最后状态以及在寄存器使用和堆栈操作码(TOS)顶端的相对位置中的改变的关系。可能在表2或表3中描述的一个或多个状态翻译需要在执行表4中所述的状态翻译前执行以便根据该Java字节码的要求满和要求空值建立对一给定Java字节码的预处理。最初状态堆栈动作最后状态动作

00000 +1 00101 R1<-TOS

00000 +2 00101 R1<-TOS-1，R2<-TOS

00000 +3 00101 R1<-TOS-2，R2<-TOS-1，R3<-TOS

00000 +4 00101 R0<-TOS，R1<-TOS-3，R2<-TOS-

2，R3<-TOS-1

00100 +1 01001 R1<-TOS

00100 +2 01110 R1<-TOS-1，R2<-TOS

00100 +3 10011 R1<-TOS-2，R2<-TOS-1，R3<-TOS

00100 -1 00000 R0<-EMPTY

01001 +1 01110 R2<-TOS

01001 +2 10011 R2<-TOS-1，R3<-TOS

01001 -1 00100 R1<-EMPTY

01001 -2 00000 R0<-EMPTY，R1<-EMPTY

01110 +1 10011 R3<-TOS

01110 -1 01001 R2<-EMPTY

01110 -2 00100 R1<-EMPTY，R2<-EMPTY

01110 -3 00000 R0<-EMPTY，R1<-EMPTY，R2<-EMPTY

10011 -1 01110 R3<-EMPTY

10011 -2 01001 R2<-EMPTY，R3<-EMPTY

10011 -3 00100 R1<-EMPTY，R2<-EMPTY，R3<-EMPTY

10011 -4 00000 R0<-EMPTY，R1<-EMPTY，R2<-

EMPTY，R3<-EMPTY

10000 -1 01111 R0<-EMPTY

10000 -2 01010 R0<-EMPTY，R3<-EMPTY

10000 -3 001001 R0<-EMPTY，R2<-EMPTY，R3<-EMPTY

10000 -4 00000 R0<-EMPTY，R1<-EMPTY，R2<-EMPTY，R3<-EMPTY

10001 -1 01100 R1<-EMPTY

10001 -2 01011 R0<-EMPTY，R1<-EMPTY

10001 -3 00110 R0<-EMPTY，R1<-EMPTY，R3<-EMPTY

10001 -4 00000 R0<-EMPTY，R1<-EMPTY，R2<-EMPTY，R3<-EMPTY

10010 -1 01101 R2<-EMPTY

10010 -2 01000 R1<-EMPTY，R2<-EMPTY

10010 -3 00111 R0<-EMPTY，R1<-EMPTY，R2<-EMPTY

10010 -4 00000 R0<-EMPTY，R1<-EMPTY，R2<-EMPTY，R3<-EMPTY

01111 +1 10000 R0<-TOS

01111 -1 01010 R3<-EMPTY

01111 -2 00101 R2<-EMPTY，R3<-EMPTY

01111 -3 00000 R1<-EMPTY，R2<-EMPTY，R3<-EMPTY

01100 +1 10001 R1<-TOS

01100 -1 01011 R3<-EMPTY

01100 -2 00110 R2<-EMPTY，R3<-EMPTY

01100 -3 00000 R1<-EMPTY，R2<-EMPTY，R3<-EMPTY

01101 +1 10010 R2<-TOS

01101 -1 01000 R1<-EMPTY

01101 -2 00111 R0<-EMPTY，R1<-EMPTY

01101 -3 00000 R0<-EMPTY，R1<-EMPTY，R3<-EMPTY

01010 +1 01111 R3<-TOS

01010 +2 10000 R3<-TOS-1，R0<-TOS

01010 -1 00101 R2<-EMPTY

01010 -2 00000 R1<-EMPTY，R2<-EMPTY

01011 +1 01100 R0<-TOS

01011 +2 10001 R0<-TOS-1，R1<-TOS

01011 -1 00110 R3<-EMPTY

01011 -2 00000 R2<-EMPTY，R3<-EMPTY

01000 +1 01101 R1<-TOS

01000 +2 10010 R1<-TOS-1，R2<-TOS

01000 -1 00111 R0<-EMPTY

01000 -2 00000 R0<-EMPTY，R3<-EMPTY

00110 +1 01011 R3<-TOS

00110 +2 01100 R0<-TOS，R3<-TOS-1

00110 +3 10001 R1<-TOS，R0<-TOS-1，R3<-TOS-2

00110 -1 00000 R2<-EMPTY

00111 +1 01000 R0<-TOS

00111 +2 01101 R0<-TOS-1，R1<-TOS

00111 +3 10010 R0<-TOS-2，R1<-TOS-1，R2<-TOS

00111 -1 00000 R3<-EMPTY

00101 +1 01010 R2<-TOS

00101 +2 01111 R2<-TOS-1，R3<-TOS

00101 +3 10000 R2<-TOS-2，R3<-TOS-1，R1<-TOS

00101 -1 00000 R1<-EMPTY

表4

应当理解在表2、表3以及表4中描述的状态和条件间的关系可被组合成一单个的状态翻译表或状态图，但它们可分别表示有助于清楚。

不同状态、条件以及基本动作间的关系可被用来定义一硬件状态机(有限态机器的形式)，用于控制指令翻译器108的操作方面。另外，这些关系可通过软件或硬件和软件的组合被模拟。

以下是可能的Java字节码的子集的例子，该例子表示对该子集的每个Java字节码来说，用于那个字节码的相关的要求满、要求空以及堆栈动作值，该字节码可结合表2、3和4使用。

　　---iconst 0

　　操作：Push int constant

　　堆栈：…＝>

　　      …，0

　　      Require-Full＝0

　　      Require-Empty＝1

　　      Stack-Action＝+1

　　---iadd

　　操作：Add int

　　堆栈：…，valuel，value2＝＞

　　      …，result

　　      Require-Full＝2

　　      Require-Empty＝0

　　      Stack-Action＝-1

　　---lload_0

　　操作：Load long from local variable

　　堆栈：…＝＞

　　      …，value.wordl，value.word2

　　      Require-Full＝0

　　      Require-Empty＝2

　　      Stack-Action＝+2

　　---lastore

　　操作：Store into long array
				
				<dp n="d17"/>
　　堆栈：…，arrayref，index，value.word1，value.word2＝＞

　　      Require-Full＝4

 　　     Require-Empty＝0

　　      Stack-Action＝-4

　　---land

　　操作：Boolean And long

　　堆栈：…，value.word1，value.word2，value2.word1，

　　      …，result.word1，result.word2

　　      Require-Full＝4

　　      Require-Empty＝0

　　      Stack-Action＝-2

　　---iastore

　　操作：Store into int array

　　堆栈：…，arrayref，index，value＝＞

　　      Require-Full＝3

　　      Require-Empty＝0

　　      Stack-Action＝-3

　　---ineg

　　操作：Negate int

　　堆栈：…，value＝＞

　　      …，result

　　      Require-Full＝1

　　      Require-Empty＝0

　　      Stack-Action＝0

上面给出了用于每个Java字节码指令的示例性的指令模板。所示的指令是实现每个Java字节码的所要求的行为的ARM指令。寄存器字域“TOS-3”、“TOS-2”、“TOS-1”、“TOS”、“TOS+1”以及“TOS+2”可根据当前采用的映射状态用从表1读出的适当的寄存器说明符代替。符号“TOS+n”表示从存储堆栈操作码的顶端的寄存器开始并向上计算寄存器值直到寄存器组未的寄存器的当前存储堆栈操作码的顶端的寄存器上的第N个寄存器，在指向一约束(wrap)的寄存器组未被指向该寄存器组中的第一寄存器。

　　iconst_0    MOV tos+1，#0

　　lload_0     LDR tos+2，[vars，#4]

　　            LDR tos+1，[vars，#4]

　　iastore     LDR Rtmp2，[tos-2，#4]

　　            LDR Rtmp 1，[tos-2，#0]

　　            CMP tos-1，Rtmp2，LSR #5

　　            BLXCS Rexc
　　            STR tos，[Rtmp1，tos-1，LSL #2]

　　lastore     LDR Rtmp2，[tos-3，#4]

　　            LDR Rtmp1，[tos-3，#0]

　　            CMP tos-1，Rtmp2，LSR #5

　　            BLXCS Rexc

　　            STR tos-1，[Rtmp1，tos-2，LSL #3]！

　　            STR tos，[Rtmp1，#4]

　　iadd        ADD tos-1，tos-1，tos

　　ineg        RSB tos，tos，#0

　　land        AND tos-2，tos-2，tos

　　            AND tos-3，tos-3，tos-1

根据所描述的技术，下面描述一单个Java字节码的示例性的由硬件翻译单元108执行的执行序列。执行序列按最初状态显示，根据正被执行的指令执行状态序列，生成ARM指令序列作为在每个状态翻译上正被执行的动作结果，整体具有将一Java字节码翻译成一RAM指令序列的结果。

　　Initiai state：00000

　　Instruction：iadd (Reguire-Full＝2， Require-Empty＝0，
Stack-Action＝-1)

　　Condition：Require-Full＞0

　　State Transition：00000＞000100

　　ARM Instruction(s)：

　　LDR R0，[Rstack，#-4]！
				
				<dp n="d19"/>
　　Next state：00100

　　Instruction：iadd (Require-Full＝2 Require-Empty＝0，
Stack-Action＝-1)

　　Condition：Requite-Full＞1

　　State Transition：00100＞101000

　　ARM Instructions(s)：

　　LDR R3，[Rstack，#-4]！

　　Next state：01000

　　Instruction：iadd (Require-Full-2，Require-Empty＝0，
Stack-Action＝-1)

　　Condition：Stack-Action＝-1

　　State Transition：01000 -1 00111

　　Instruction template：

　　ADD tos-1，tos-1，tos

　　Arm Instructions(s)(after substitution)：

　　ADD R3，R3，R0

　　Next state：00111

图6用不同的方法描述执行多个另外的Java字节码指令。图6的上面部分描述ARM指令序列以及映射状态的改变以及在执行一iadd字节码指令时发生的寄存器内容。最初映射状态是寄存器组中的所有为空的寄存器一致的00000。所生成的前两个ARM指令用来将两个堆栈操作码弹入存储堆栈操作码的具有堆栈“TOS”寄存器的顶端的为R0的寄存器中。第三个ARM指令实际上执行添加操作以及将结果写入寄存器R3(其现在为堆栈操作码的顶端)同时使用先前用掉保存在寄存器R1中的堆栈操作码，从而产生一整个堆栈操作-1。

然后，处理进行到执行两个Java字节码，每个Java字节码表示两个堆栈操作码的一长载荷。用于第一Java字节码的为2的要求空条件被立即满足并且得出和执行相应的两个ARM LDR指令。在执行第一长载荷Java字节码后映射状态为01101。在这种状态下，寄存器组仅包括一单个的空寄存器。下一Java字节码长载荷指令具有为2的要求空值，为2的要求空值不被满足，因此所要求的第一动作是使用ARM STR指令将一堆栈操作码压入可寻址存储器。这释放了由一个新的堆栈操作码使用的寄存器组中的一个寄存器，然后，该操作码可作为两个随后的LDR指令的一部分被载入。如上所述，指令翻译可通过硬件、软件或两者的结合来实现。假定下面是根据上面描述的技术生成的一示范性的软件翻译程序的一部分。

　　Interpret     LDRB Rtmp，[Rjpc，#1]！

　　LDR pc，[pc，Rtmp，lsl#2]

　　DCD 0

　　…

　　DCD do_iconst_0；Opcode 0x03

　　…

　　DCO do_lload_0；Opcode 0x1e

　　…

　　DCD do_iastore；Opcode 0x4f

　　DCD do_lastore；Opcode 0x50

　　…

　　DCD do_iadd；Opcode 0x60

　　…

　　DCD do_ineg；Opcode 0x74

　　…

　　DCD do_land；Opcode 0x7f

　　do_iconst_0      MOV R0，#0

　　STR R0，[Rstack]，#4

　　B Interpret

　　do_lload_0      LDMIA Rvars，{R0，R1}

　　STMIA Rstack！，{R0，R1}

　　B Interpret

　　do_iastore      LDMDB Rstack！，{R0，R1，R2}

　　LDR Rtmp2，[r0，#4]

　　LDR Rtmp1，[r0，#0]

　　CMP R1，Rtmp2，LSR #5

　　BCS ArrayBoundException

　　STR R2，[Rtmp1，R1，LSL #2]
				
				<dp n="d21"/>
　　B Interpret

　　do_lastore    LDMDB Rstack！，{R0，R1，R2，R3}

　　LDR Rtmp2，[r0，#4]

　　LDR Rtmp1，[r0，#0]

　　CMP R1，Rtmp2，LSR #5

　　BCS ArrayBoundException

　　STR R2，[Rtmp1，R1，LSL #3]！

　　STR R3，[Rtmp1，#4]

　　B Interpret

　　do_iadd       LDMDB Rstack！，{r0，r1}

　　ADD r0，r0，r1

　　STR r0，[Rstack]，#4

　　B InterPret

　　do_ineg       LDR r0，[Rstack，#-4]！

　　RSB tos，tos，#0

　　STR r0，[Rstack]，#4

　　B Interpret

　　do_land       LDMDB Rstack！，{r0，r1，r2，r3 }

　　AND r1，r1，r3

　　AND r0，r0，r2

　　STMIA Rstack！，{10，r1}

　　B Interpret

　　State_00000_InterPret LDRB Rtmp，[Rjpc，#1]！

　　LDR pc，[pc，Rtmp，lsl #2]

　　DCD 0

　　DCD State_00000_do_iconst_0；Opcode 0x03

　　DCD State_00000_do_lload_0；Opcode 0x1e

　　DCD State_00000_do_iastore；0pcode 0x4f

　　DCD State_00000_do_lastore；Opcode 0x50

　　DCD State_00000_do_iadd；Opcode 0x60

　　DCD State_00000_do_ineg；Opcode 0x74
				
				<dp n="d22"/>
　　DCD State_00000_do_land；Opcode 0x7f

　　State_00000_do_iconst_0 MOV R1，#0

　　B State_00101_Interpret

　　RSB r1，r1，#0

　　B State_00101_Interpret

　　State_00000_do-land LDR r0[Rstack.  #-4]！

　　LDMDB Rstack！，{r1，r2，r3)

　　AND r2，r2，r0

　　AND r1，r1，r3

　　B State_01010_Interpret

　　State_00100_InterPret LDRB Rtmp，[Rjpc，#1]！

　　LDR pc，[pc，Rtmp，lsl #2]

　　DCD 0

　　DCD State_00100_do_iconst-0；Opcode 0x03

　　DCD State_00100_d0_lload_0；Opcode 0x1e

　　DCD State_00100_do_iastore；Opcode 0x4f

　　DCD State_00100_do_lastore；0pcode 0x50

　　DCD State_00100_do_iadd；Opcode 0x60

　　DCD State_00100_do_ineg；0pcode 0x74

　　DCD State_00100_do_land；Opcode 0x7f

　　State_00100_dO_iconst_0 MOV R1，#0

　　B State_01001_InterPret

　　State_00100_do_lload_0 LDMIA Rvars，{r1，R2}

　　B State-01110_Interpret

　　State_00100_do_iastore LDMDB Rstack！，{r2，r3}

　　LDR Rtmp2，[r2，  #4]

　　LDR Rtmp1，[r2，  #0]
				
				<dp n="d23"/>
　　CMP R3，Rtmp2，LSR #5

　　BCS ArrayBoundException

　　STR R0，[Rtmp1，R3，lsl #2]

　　B State_00000_Interpret

　　State_00100_do_lastore LDMDB Rstack！，{r1，r2，r3}

　　LDR Rtmp2，[r1，#4]

　　LDR Rtmp1，[r1，#0]

　　CMP r2，Rtmp2，LSR #5

　　BCS AsrayBoundException

　　STR r3，[Rtmp1，r2，lsl #3]！

　　STR r0，[Rtmp1，#4]

　　B State_00000_Interpret

　　State_00100_do_iadd LDR I3，[Rstack，#-4]！

　　ADD r3，r3，r0

　　B State_00111_InterPret

　　State_00100_do_ineg RSB r0，r0，#0

　　B State_00100_InterPret

　　State_0100_do_land LDMDB Rstack！，{r1，r2，r3}

　　AND r2，r2，r0

　　AND r1，r1，r3

　　B State_01010_Interpret

　　State_01000_Interpret LDRB Rtmp，[Rjpc，#1]！

　　LDR pc，[pc，Rtmp，lsl #2]

　　DCD 0

　　DCD State_01000_do_iconst_0；Opcode 0x03

　　DCD State_01000_do_lload 0；0pcode 0x1e

　　DCD State_01000_do_iastore；Opcode 0x4f

　　DCD State_01000_do_lastore；Opcode 0x50

　　DCD State_01000_do_iadd；Opcode 0x60
				
				<dp n="d24"/>
　　DCD State_01000_do_ineg；Opcode 0x74

　　DCD State_01000-do_land；Opcode 0x7f

　　State 01000_do_iconst_0 MOV R1，#0

　　B State_01101_Interpret

　　State_01000_do_lload_0 LDMIA Rvars，{r1，r2}

　　B State_10010_InterPret

　　State_01000_do_iastore LDR r1，[Rstack，#-4]！

　　LDR RtInP2，[R3，#4]

　　LDR RtIUP1，[R3，#01

　　CMP r0，Rtmp2，LSR #5

　　BCS AsrayBounasxception

　　STR r1，[Rtmp1，r0，lsl #2]

　　B State_00000_Interpret

　　State_01000_do_lastore LDMDB RstaCk！，{r1，r2}

　　LDR Rtmp2，{r3，#4}

　　LOR Rtmp1，{R3，#0}

　　CMP r0，Rtmp2，LSR #5

　　BCS ArrayBoundException

　　STR r1，[Rtmp1，r0，lsl #3]！

　　STR r2，[Rtmp1，#4]

　　B State_00000_Interpret

　　State_01000_do_iadd ADD r3，r3，r0

　　B State_00111_Interpret

　　State_01000_do_ineg RSB r0，r0，#0

　　B State-01000_Interpret

　　State_01000_do_land LDMDB Rstack！，{r1，r2}

　　AND R0，R0，R2

　　AND R3，R3，R1

图7描述一Java字节码指令“laload”，该指令具有从堆栈位置的顶端开始的由两个数据字指定的一数据组中读取两个数据字的功能。然后从该数据组中读取的两个字替换指定它们的位置的两个字并形成最顶端的堆栈入口。

为使“laload”指令具有足够的寄存器空间用于暂时存储从该数组中提取的堆栈操作码而不重写指定该数组和该数据组中的单元的输入操作码，该Java字节码指令被指定为具有为2的要求空值，即专用于堆栈操作码存储的寄存体中的两个寄存器必须在执行仿真“laload”指令的ARM指令前必须被清空。如果当该Java字节码被冲突时没有两个空的寄存器，那么可执行存储操作(STRs)来将当前保存在寄存器中的堆栈操作码推出存储器以便为临时存储需要腾出空位并符合用于该指令的要求空值。

指令还具有为2的要求满值因为该数据地址是由一数组单元和那个数组中的一索引指定作为两个分开的堆栈操作码。该图表示第一状态已经满足要求满或要求空状态并具有一“01001”的映射状态。该“laload”指令被分成三个ARM指令。这些中的第一个将数组子串引用载入寄存器组外的作为堆栈操作码的一寄存器高速缓存器的一备用的工作寄存器。然后第二指令使用该数组子串引用结合该数组中的一索引值来访问第一数组字，该数组字被写入专用于堆栈操作码存储的一个空寄存器。

应当特别注意在执行前两个ARM指令后，该系统的映射状态没有改变且堆栈指针的顶端仍然在以所指定为空的寄存器开始的地方。

在ARM指令序列中的最后指令将第二数组字载入用于存储堆栈操作码的寄存器组中。由于这是最后指令，如果在这期间的确有一中断发生，那么直到该指令完成才会提供该中断，因此用该指令通过改变存储堆栈操作码的寄存器的映射状态的一改变能安全地改变该输入状态。在该例子中，映射状态改变为在第二数组字中放置堆栈指针的新的顶端以及表示数据引用的输入变量以及索引值现有均为空寄存器的“01011”，即，标记这些寄存器为空与从保存它们的堆栈中移出这些值等效。

应当注意“laload”指令的整个堆栈动作没有改变保存在寄存器中的堆栈操作码的数量的同时，一映射状态交换仍然发生。基于执行的最后操作所执行的映射状态的改变被硬连线到指令翻译器作为被翻译的Java字节码的函数并且由“swap”参数表示，“swap”参数表示为“laload”指令的特性。

虽然该图的例子是一特殊的指令，应当理解，所提出的原理可被扩展到被仿真为ARM指令或其他类型的指令的许多不同的Java字节码指令。

图8是示意地说明上述技术的流程图。在步骤10，从存储器提取Java字节码。在步骤12，用于那个Java字节码的要求满和要求空值被检查。如果既不符合要求空也不符合要求满条件，那么堆栈操作码(可能是多个堆栈操作码)的各自的PUSH和POS操作可用步骤14和16执行。应当注意该特定的系统不允许同时不满足要求空和要求满条件。通过步骤14和16的多个通路可被要求直到步骤12的条件满足为止。

在步骤18，选择在用于Java字节码有关的翻译模板中指定的第一个ARM指令。在步骤20，做一核对以便确定所选择的ARM指令是否是在步骤10提取的Java字节码的仿真中被执行的最后指令。如果被执行的ARM指令是最后指令，那么步骤21用来更新程序计数值以指向将被执行的指令序列中的下一Java字节码。应当理解，如果ARM指令是最后指令，那么它将完成其执行，而不管现在是否发生中断，因此，它能安全地更新下一Java字节码的程序计数值并从那一点重启动执行，因为系统的状态将达到该Java字节的匹配标准、不中断、全执行。如果在步骤20的测试表示还未到最后字节码，那么将忽略程序计数值的更新。

步骤22执行当前的ARM指令。在步骤24，做一测试以便确定是否还有要求作为模拟的一部分执行的ARM指令。如果还有ARM指令，那么在步骤26选择它们中的一个并返回步骤20处理。如果没有另外的指令，那么处理进入步骤28，在该步骤，为相关的Java字节码指定的任何映射改变/交换被执行以便反映堆栈单元的所需顶端以及保存堆栈操作码的不同寄存器的全/空状态。

图8也示意地描述这些点，在这些点上如果确定一中断是有用的，那么在一中断后处理重启动。一中断开始在执行当前的ARM指令后在步骤22被使用以及无论被存储为具有字节码序列的返回点的当前程序计数值是什么，那么步骤21将仅更新程序计数值，因此这将指向下一Java字节码(或ARM指令应当使指令集翻译正好被启动)。如果当前执行的ARM指令是除序列中最后指令外的任何指令，那么程序计数值将仍然与在开始执行相关Java字节码所表示的相同，因此，当返回时，整个Java字节码将被重新执行。

图9描述接收Java字节码和输出翻译后的ARM指令流(或相应的控制信号)以控制处理器内核的动作的Java字节码翻译单元68。如前所述，Java字节码翻译器68使用指令模板将简单的Java字节码翻译成ARM指令或ARM指令序列。当每个Java字节码已经被执行时，那么在调度控制逻辑70中的计数值被减少。当该计数值到达0时，那么Java字节码翻译单元68将一ARM指令分支发布给适当管理线程或任务间的调度的调度码。

虽然简单的Java字节码是由提供基于这些字节码的执行的高速硬件的Java字节码翻译单元68本身处理，要求更复杂的处理操作的字节码被发送到以解释程序(如在本说明书中前面提出的那些例程的选择)集合的形式提供的软件解释程序。更准确地说，Java字节码翻译单元68能确定它已经接收的字节码不是由硬件翻译器所支持的那一个，因此，可根据那个Java字节码对一地址做一分支，在该地址用于翻译那个字节码的软件例程被发现或引用。当调度逻辑70表示需要调度操作来产生对该调度码的分支时可使用该机理。

图10更详细地描述图9的实施例的操作和硬件和软件间的任务分离。在步骤72由Java字节码翻译单元68接收所有Java字节码并使计数递减。在步骤74，核对计数值是否已经到0，如果计数值已经为0(从硬连线到该系统的预定值或可由用户控制的/编程的值递减计数)，那么在步骤76对调度码做一分支。只要在步骤76高度码已经完成，控制被返回到该硬件以及处理进入步骤72，在该处，提取下一Java字节码以及计数再次递减。由于计数到达0，那么它现在将重新面临一个新的、非零值。另外，新值可被迫进入计数同时在步骤76退出调度过程。

如果在步骤74的测试表示计数不等于0，那么步骤78提取Java字节码。在步骤80，确定提取的字节码是否是在步骤82可由硬件翻译执行的一简单的字节码或是否要求更复杂的处理，因此，在步骤84应当不存在用于软件翻译程序。如果不存在对软件解释程序的处理，那么只要这个过程已经完成，控制返回硬件，在该处，步骤72再次递减计数来考虑提取下一Java字节码。

图11表示另外的控制装置。在处理开始时，在步骤86，指令信号(调度信号是不确定的(dessert)。在步骤88，提取的Java字节码被检验以查看它是否是硬件翻译器所支持的一个简单的字节码。如果硬件翻译器不支持，那么控制被分送到步骤90的解释软件，然后，在步骤90执行ARM指令例程来翻译Java字节码。如果该字节码是硬件翻译所支持的简单的一个，那么处理进入步骤92，在步骤92，一个或多个ARM指令通过充当多周期有限态机器的Java字节码翻译单元68按顺序发行。只要在步骤90或在步骤92已经正确处理该Java字节码，那么处理进入步骤94，在步骤94，指令信号在步骤86不确定前确定一短周期。确定的指令信号向外电路表示已经到达合适的安全点，在该点处，由于部分执行一个解释的或翻译的指令，基于调度中断的定时器能产生而不冒数据完整性的风险。

图12描述可被用来响应在图11中生成的指令信号的典型的电路图。定时器96在给定时限期满后定期生成一定时器信号。该定时器信号被存储在锁存器98中直到由清除定时器中断信号被清零为止。在步骤94锁存器98的输出通过一AND门100与确定的指令信号逻辑结合。当该锁存器被设置以及指令信号被确定时，那么生成一中断作为AND门100的输出并被用来触发一中断，该中断使用在系统中提供的用于标准中断处理的中断处理机制来执行调度操作。只要中断信号已经产生，依次触发产生清零锁存器98的清定时器中断信号直到下一定时器输出脉冲产生。

图13是表示图12的电路的操作的信号图。处理器内核时钟信号以有规律的频率产生。定时器96在预定周期生成定时器信号以表示当安全时，调度操作应当被启动。定时器信号被锁住。指令信号以由时间间隔分开的次数产生，该时间间隔取决于一特定的Java字节码被执行有多快。一简单的Java字节码可在一单个的处理器内核时钟周期，或更典型的两个或三个中执行，而提供一高水平管理类型功能的一个复杂的Java字节码在由该软件翻译程序完成其执行前可花费几百个处理器时钟周期。在另一种情形中，挂起的确定的锁住的定时器信号触发一调度操作直到指令信号发布表示对开始调度操作它很安全为止。锁住的定时器信号以及指令信号的同时发生触发产生一中断信号，该中断信号其后立即被清锁存器98的清除信号跟踪。

Claims

1、用于处理数据的装置，所述装置包括：

一处理器内核，用来执行由第一指令集的指令指定的操作；

重启动逻辑，用于在所述中断后重启动执行；其中

2、如权利要求1所述的装置，其中所述翻译器输出信号包括形成所述第一指令集的一个指令的信号。

3、如权利要求1和2中任何一个所述的装置，其中所述翻译器输出信号包括控制所述处理器内核的操作的控制信号以及在所述第一指令集的译码指令上产生的匹配控制信号。

4、如权利要求1、2和3中任何一个所述的装置，其中所述翻译器输出信号包括控制所述处理器内核的操作的控制信号以及不是由在所述第一指令集的译码指令上产生的控制信号指定的特殊参数。

5、如以上任何一个权利要求所述的装置，其中所述重启动逻辑是所述指令翻译器的一部分。

6、如以上任何一个权利要求所述的装置，其中所述重启动逻辑将一指针存储到正被翻译的所述第二指令集的指令中的一重启动单元，所述指针基于所述最后操作的执行向前移。

7、如权利要求6所述的装置，其中所述指针是指向存储当前正被翻译的所述第二指令集的一个指令的一个存储器单元的一个存储地址的一程序计数值。

8、如以上任何一个权利要求所述的装置，其中所述第二指令集的指令根据保存在一堆栈中的堆栈操作码指定将执行的操作以及所述输入变量包括输入堆栈操作码。

9、如权利要求8所述的装置，其中通过执行所述第二指令集的所述至少一个指令从所述堆栈中移出任何堆栈操作码直到开始执行所述最后操作后才被移出。

10、如权利要求8和9中任何一个所述的装置，其中通过执行所述第二指令集的所述至少一个指令添加到所述堆栈的任何操作码直到开始执行所述最后操作后才被添加。

11、如以上任何一个权利要求所述的装置，其中所述输入变量包括未在所述第二指令中指定的系统状态变量。

12、如以上任何一个权利要求所述的装置，其中所述处理器具有包含多个寄存器的寄存器体以及所述第一指令集的指令根据保存在所述寄存器中的寄存器操作码执行操作。

13、如权利要求12所述的装置，其中在所述寄存器体中的寄存器组保存来自所述堆栈的顶端的堆栈操作码。

14、如权利要求13所述的装置，其中所述指令翻译器具有多个映射状态，其中在所述寄存器组中的不同寄存器保存来自所述堆栈中的不同位置的堆栈操作码，所述指令翻译器当所述最后操作被执行时可在映射状态间移动以便更新所述输入变量。

15、如以上任何一个权利要求所述的装置，其中所述第二指令集的所述指令是Java虚拟机指令。

16、一种处理数据的方法，所述方法包括步骤：

执行由第一指令集的指令指定的操作；

在所述中断后重启动执行；其中

17、一种计算机程序产品，保存用于控制计算机执行如权利要求15所述的方法的计算机程序。