CN1484787A - 处理器流水线中的硬件指令翻译 - Google Patents

处理器流水线中的硬件指令翻译 Download PDF

Info

Publication number
CN1484787A
CN1484787A CNA018200931A CN01820093A CN1484787A CN 1484787 A CN1484787 A CN 1484787A CN A018200931 A CNA018200931 A CN A018200931A CN 01820093 A CN01820093 A CN 01820093A CN 1484787 A CN1484787 A CN 1484787A
Authority
CN
China
Prior art keywords
instruction
equipment
instruction set
pipelining
translator
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
CNA018200931A
Other languages
English (en)
Inventor
E��C������
E·C·内维尔
A·C·罗斯
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
ARM Ltd
Original Assignee
Advanced Risc Machines Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Advanced Risc Machines Ltd filed Critical Advanced Risc Machines Ltd
Publication of CN1484787A publication Critical patent/CN1484787A/zh
Pending legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/48—Program initiating; Program switching, e.g. by interrupt
    • G06F9/4806—Task transfer initiation or dispatching
    • G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30101—Special purpose registers
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
    • G06F9/30149—Instruction analysis, e.g. decoding, instruction word fields of variable length instructions
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
    • G06F9/3016—Decoding the operand specifier, e.g. specifier format
    • G06F9/30167—Decoding the operand specifier, e.g. specifier format of immediate specifier, e.g. constants
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/3017—Runtime instruction translation, e.g. macros
    • G06F9/30174—Runtime instruction translation, e.g. macros for non-native instruction set, e.g. Javabyte, legacy code
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3802—Instruction prefetching
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3802—Instruction prefetching
    • G06F9/3814—Implementation provisions of instruction buffers, e.g. prefetch buffer; banks
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3853—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution of compound instructions
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3861—Recovery, e.g. branch miss-prediction, exception handling
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Advance Control (AREA)
  • Executing Machine-Instructions (AREA)
  • Devices For Executing Special Programs (AREA)

Abstract

一种处理系统具有指令流水线(30)和处理器核芯。在指令流水线中取阶段(32)的下游处设置有一指令翻译器，它用于将非本机指令翻译成本机指令操作。所述指令翻译器能以允许生成变长本机指令操作序列以模拟非本机指令的方式生成本机指令操作的多步序列。所述取阶段配备有字缓存(62)，它存储当前指令字和下一个指令字。因此，可以提供要跨越从存储器中读出的指令字的变长非本机指令，以便快速解码，避免了耗费能力的存储器多次取操作。

Description

处理器流水线中的硬件指令翻译
本发明涉及数据处理系统。具体地说，本发明涉及这样的数据处理系统，其中，在处理器流水线内将指令从一个指令集翻译成另一个指令集。
周知提供了这样的处理系统，其中，在指令流水线内将指令从第一指令集翻译成第二指令集。在这类系统中，要加以翻译的每条指令均映射成单条本机指令。这类系统的一个实例是ARM有限公司生产的处理器，这种处理器支持ARM和Thumb指令代码。
周知提供了这样的处理系统，其中，可将非本机指令翻译成包括多条本机指令的本机指令序列。US-A-5937193说明了这种系统的一个实例。这种系统将Java字节码映射成32位的ARM指令。这种翻译是在指令进处理器流水线之间进行的并使用了存储器地址重映射技术。Java字节码用于查找存储器中模拟Java字节码活动的ARM指令序列。
US-A-5937193的系统具有若干相关缺陷。这种系统在使用存储器和存储器取操作的方式上效率低下。即使ARM指令序列可以被设置成占据较少的存储器空间，但它们仍都要占据同样大小的存储器空间。在对各Java字节码解码时需要从存储器中多次取ARM指令，这就会很不利地消耗能力并且负面地影响效率。被翻译的指令序列是固定的，从而在执行能够导致不同或更为优化的指令翻译的各Java字节码时，难以将不同的起始系统状态考虑在内。
用于在指令集之间进行翻译的周知系统的实例以及其它背景信息可在以下专利中找到，它们是：US-A-5805895、US-A-3955180、US-A-5970242、US-A-5619665、US-A-5826089、US-A-5925123、US-A-5875336、US-A-5937193、US-A-5953520、US-A-6021469、US-A-5568646、US-A-5758115、US-A-5367685、《IBM技术通报》1988年3月第308-309页的“用于精简指令集计算机的系统/370模拟器辅助处理器”、《IBM技术通报》1986年7月第548-549页的“全功能系列/1指令集模拟器”、《IBM技术通报》1994年3月第605-606页的“RISC处理器上的实时CISC结构的Hw模拟器”、《IBM技术通报》1998年3月第272页的“用EMULATION控制块提高效率”、《IBM技术通报》1995年1月第537-540页的“用于在精简指令集计算机/循环系统中进行代码模拟的快速指令解码”、《IBM技术通报》1993年2月第231-234页的“高性能复式结构处理器”、《IBM技术通报》1989年8月第40-43页的“系统/370的I/O通道的程序通道命令字预取操作”、《IBM技术通报》1985年6月第305-306页的“全微码控制的模拟结构”、《IBM技术通报》1972年3月第3074-3076页的“用于模拟的Op代码与状态处理”、《IBM技术通报》1982年8月第954-956页的“对大系统的带有最经常使用的指令的微处理器进行芯片上的微编码以及适用于对其余指令进行编码的原语”、《IBM技术通报》1983年4月第5576-5577页的“模拟指令”、S Furber所著图书《ARM系统体系结构》、Hennessy和Patterson所著图书《计算机体系结构：定量方法》以及Tim Lindholm和Frank Yellin所著图书《Java虚拟机规范》第1和第2版。
从一个方面看，本发明提供了用于处理数据的设备，该设备包括：
一处理器核芯，它可执行第一指令集的指令所指定的操作，所述处理器核芯具有这样的指令流水线，可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进；以及
一指令翻译器，它可将第二指令集的指令翻译成与第一指令集的指令相对应的翻译器输出信号；其中，
所述指令翻译器位于上述指令流水线内并翻译业已被从前述存储器中取至所述指令流水线内的第二指令集的指令；
所述第二指令集的至少一个指令指定了需要多个操作的多步操作，所述多个操作可由第一指令集的指令来指定，以便由前述处理器核芯来加以执行；以及
所述指令翻译器可生成翻译器输出信号序列，以便控制前述处理器核芯去执行上述多步操作。
本发明提供了上述位于处理器核芯本身的指令流水线内的指令翻译器，该翻译器处于取指阶段的下游。通过这种方式，非本机指令(第二指令集指令)可按与本机指令(第一指令集指令)相同的方式存储在存储系统内，从而消除了对存储器系统利用的限制。此外，对各非本机指令而言，对来自存储器系统的非本机指令的单次存储器取操作发生在处理器流水线中产生任何多步本机指令操作序列的同时。这就会降低存储器取操作的能力消耗并改进效率。再有，流水线中的指令翻译器能沿流水线其余部分往下发出可变数量的要执行的本机指令操作，这要取决于正被解码的特定本机指令并取决于任何在本机操作有效执行所需的非本机操作时会产生影响的周围系统的状态。
应该注意，指令翻译器可生成翻译器输出信号，这些信号可全部并完整地表示来自第一指令集的本机指令。这种结构允许简单地重新使用被设计成与第一指令集的指令一道操作的硬件逻辑。但是，应该注意，指令翻译器也可生成这样的翻译器输出信号，它们是控制信号，可在不与本机指令直接相对应的情况下产生与本机指令一样的效果或额外提供诸如扩展的操作数域之类的本身不是由第一指令集的指令直接提供的其它操作。
在指令流水线中设置指令翻译器能当在不依赖存储器组织的情况下翻译成非本机指令的本机指令时将处理器核芯的程序计数值用于按通常的方式从存储器中取出非本机指令。此外，可在与非本机指令是翻译成本机指令的单步还是多步操作无关的情况下根据对这些非本机指令的执行来控制程序计数值的前进。用程序计数值跟踪非本机指令的执行，可最佳地简化对中断、分支和系统结构其它方面进行处理的方法。
按被认为是提供有限状态机的方式在指令流水线中设置指令翻译器具有这样的结果即：指令翻译器能更容易地调节所翻译的指令操作以反映系统状态以及正被翻译的非本机指令。作为一个最佳实例，当第二指令集指定以堆栈为基础的处理而处理核心是以寄存器为基础的处理时，则可以用一组寄存器来有效地缓存堆栈操作数，以使处理加快。在这种情况下，所翻译的指令序列会随特定的堆栈操作数是否被缓存在寄存器内或是否必须要取出该堆栈操作数而变。
为了减少指令翻译器可能对执行本机指令产生的影响，最佳实施例是这样的：指令流水线内的指令翻译器配备有旁通通路，因此，在按本机指令处理模式进行操作时，可在不受指令翻译器影响的情况下处理本机指令。
应该注意，本机指令和非本机指令可有多种不同的形式。但是，在第二指令集的非本机指令是Java虚拟机指令时，本发明特别有用，因为，将这些指令翻译成本机指令会有许多问题和困难，这些问题和困难本发明可以解决。
从另一个方面看，本发明提供了一种用带有指令流水线的处理器核芯来处理数据的方法，可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进，所述处理器核芯能执行第一指令集所指定的操作，所述方法包括下列步骤：
将指令取至上述指令流水线；以及
用前述指令流水线中的指令翻译器将取出的第二指令集的指令翻译成与上述第一指令集的指令相对应的翻译器输出信号；其中
所述第二指令集的至少一个指令指定了需要多个操作的多步操作，所述多个操作可由前述第一指令集来指定，以便由上述处理器核芯来加以执行；以及
所述指令翻译器可生成一系列翻译器输出，以便控制上述处理器核芯，从而执行前述多步操作。
本发明还提供了一种计算机程序产品，它存放有计算机程序，以便按着上述技术控制计算机。
当在指令流水线中取要翻译的指令时，若要翻译的指令是变长指令时，则会出现问题。在取定长指令时，指令该水线的取阶段具有相对可预测的操作。例如，若在每个指令周期上执行一条指令，则取阶段可设置成根据每一指令周期取一条指令，以便使指令流水线满。但是，当被取出的指令是变长的时，则在识别指令之间边界方面存在困难。因此，在提供定长存储读取操作的存储器系统中，特定的变长指令可跨越存储读取操作，从而需要第二次取操作，以读取指令的最后部分。
从又一个方面看，本发明提供了用于处理数据的设备，该设备包括：
一处理器核芯，它可执行第一指令集的指令所指定的操作，所述处理器核芯具有这样的指令流水线，可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进；以及
一指令翻译器，它可将第二指令集的指令翻译成与第一指令集的指令相对应的翻译器输出信号；其中，
所述第二指令集的指令是变长指令；
所述指令翻译器位于上述指令流水线内并翻译业已被从前述存储器中取至所述指令流水线的取阶段的第二指令集的指令；
所述指令流水线的取阶段包括一指令缓存，它存放有至少一个当前指令字以及从所述存储器中取出的下一个指令字，因此，若所述第二指令集的变长指令在前述当前指令字内开始并延伸至所述下一个指令字，则该下一个指令字可在上述流水线内获得，以便在不需要另外的取操作的情况下由所述指令翻译器来翻译。
本发明在取阶段内提供了一缓存，以存储至少一个当前指令字和下一个指令字。通过这种方式，若特定的变长指令超出当当前指令字延伸至下一个指令字，则该指令业已被取出因而也是可使用的，从而能立即进行解码和使用。这可避免任何第二次性能上低效的取操作。应该注意，在流水线中提供一缓存下一指令字和当前指令字并支持变长指令的取阶段能使取阶段相对于指令流水线中其余阶段而言更为异步的方式进行操作。这一点与其中流水线阶段会同步操作的用于执行定长指令的指令流水线中的通常操作趋势相反。
本发明的将指令缓存在取阶段内的实施例能很好地适用于这类系统，该系统具有就本发明第一方面所说的上述最佳特征。
从再一个方面看，本发明提供了用能执行第一指令集所指定的操作的处理器核芯来处理数据的方法，所述处理器核芯具有这样的指令流水线，可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进，所述方法包括下列步骤：
将指令取至上述指令流水线；以及
用所述指令流水线内的指令翻译器将取出的第二指令集的指令翻译成与第一指令集的指令相对应的翻译器输出信号；其中，
所述第二指令集的指令是变长指令；
所述指令翻译器位于上述指令流水线内并翻译业已被从前述存储器中取至所述指令流水线的取阶段的第二指令；以及
所述指令流水线的取阶段包括一指令缓存，它存放有至少一个当前指令字以及从所述存储器中取出的下一个指令字，因此，若所述第二指令集的变长指令在前述当前指令字内开始并延伸至所述下一个指令字，则该下一个指令字可在上述流水线内获得，以便在不需要另外的取操作的情况下由所述指令翻译器来翻译。
以下参照附图仅以举例的方式说明本发明的实施例，附图中：
图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可绕过指令翻译器阶段并按本质上没有改变的方式进行操作来提供对本机指令的解码。
在指令流水线30中，指令翻译器阶段42被说明为生成翻译器输出信号，这些信号完全表示相应的ARM指令并且通过多路复用器传至本机指令解码器34。指令翻译器42还生成某些额外的控制信号，这些信号被传给本机指令解码器34。本机指令编码中的位空间限制会限制本机指令所指定的操作数的范围。这些限制不一定由非本机指令所分担。额外的控制信号能传送额外的指令，该指令规定了源于非本机指令的信号，这些信号是不能在存储于存储器内的本机指令中指定的。作为一个实例，本机指令对用作本机指令中的直接操作数域仅提供较少数量的位，而非本机指令则允许有扩展的范围，这一点可通过用额外的控制信号而加以利用，从而将直接操作数的扩展部分传至所翻译的本机指令之外的本机指令解码器34，所翻译的本机指令也被传至本机指令解码器34。
图2示出了另一个指令流水线44。在这一实例中，系统配备有两个本机指令解码器46、48以及一个非本机指令解码器50。非本机指令解码器50被限制在这样一些操作，这些操作可以通过用以支持本机指令的执行阶段52、存储阶段54和回写阶段56来指定。因此，非本机指令解码器50必须将非本机指令有效地翻译成本机操作(这些操作可以是单个的本机操作，也可以是一系列本机操作)，然后将适当的控制信号提供给执行阶段52，以便实现上述一个或多个本机操作。应该注意，在本例中，非本机指令解码器不会产生构成本机指令的信号，而是提供指定本机指令(或扩展的本机指令)操作的控制信号。所生成的控制信号可能会与本机指令解码器46、48所产生的控制信号不相匹配。
在操作中，用所说的多路分解器根据特定的处理模式将取阶段58所取出的指令有选择地提供给指令解码器46、48或50中的一个。
图3更详尽地在原理上说明了指令流水线的取阶段。取指逻辑电路60从存储器系统中取出定长指令字并将它们提供给指令字缓存62。指令字缓存62是摆动缓存，它具有两侧，因此，该缓冲可存储当前的指令字和下一个指令字。在当前指令字业已被完全解码并且解码已前进至下一个指令字时，取指逻辑电路60就把要从存储器中取出的下一个指令字来替换前一个当前指令字，也就是说，摆动缓存的各侧会以交替的方式按二递增这两侧所连续存储的指令字。
在所述的实例中，Java字节码指令的最大指令长度是三个字节。因此，设置有三个多路复用器，这些复用器能选择字缓存62两侧中的任何三个相邻字节并将它们提供给指令翻译器64。字缓存62和指令翻译器64还配备有旁通通路66，以便在取出本机指令并对其解码时使用。
应该看到，从存储器中取出每个指令字一次并将其存储在字缓存62内。当指令翻译器64将Java字节码翻译成ARM指令时，单个的指令字可以允许从中读出多条Java字节码。当指令翻译操作被限制在指令流水线内时在，不需要多次读取存储器系统并且在不消耗存储器资源或将其它限制施加于存储器系统的情况下，就可以生成所翻译的变长本机指令序列。
程序计数器值与当前正被翻译的各Java字节码有关。所述程序计数值沿流水线的阶段前进，以便如果必要的话，每一级都能使用与其正在处理的特定Java字节码有关的信息。对翻译成一系列多个ARM指令操作的Java字节码其程序计数值不会增加，直至所述序列中的最后ARM指令操作开始执行。仍然直接指向存储器内正被执行的指令的方式来保持程序计数器的值，能最佳地简化系统的其它方面，诸如调试查错和分支目标计算之类。
图4概略地说明了从指令缓存62中读取变长Java字节码指令。在第一阶段，读取长度为1的Java字节码指令并对其解码。下一阶段是这样的Java字节码，其长度为三字节并跨越业已从存储器中取出的两个相邻指令字。这两个相邻指令字出现在指令缓存62内，因此，指令解码和处理不会因变长指令跨越取出的指令字而延迟。一旦从指令缓存62中读取了三个Java字节码，就开始重填先前取出的指令字，因为，后续的处理会继续对业已存在的后续指令字的Java字节码进行解码。
图4所示的最后阶段说明了正被读取的第二个三字节码指令。该指令也跨越指令字。如果前一个指令字尚未完成其重填，则指令的读取会因流水线停顿而延迟，直至适当的指令字已被存储进指令缓存62。在某些实施例中，时标可以是这样的即：流水线不会因这种行为而停顿。应该注意，这种特殊实例是不常出现的，因为，大多数Java字节码要比所示的实例短，因此，两次连续对跨越指令字的指令进行解码是不太常见的。有效信号可以用如下方式与指令缓冲器62中的每个指令字相关联，即它能发信号表示在从中读取了Java字节码之前指令字是否已被适当地重填了。
图5示出了数据处理系统102，它包括处理器核芯104和寄存器库106。指令翻译器108设置在指令通路内以便将Java虚拟机指令翻译成要提供给处理器核芯104的本机ARM指令(或与之相对应的控制信号)。当本机ARM指令从可寻址的存储器中取出时，可绕过指令翻译器108。可寻址的存储器可以是诸如带有在芯片之外的RAM存储器的高速缓存存储器的存储器系统。将指令翻译器108设置在存储器系统的下游特别是高速缓存存储器的下游能有效地使用存储器系统的存储容量，因为，需要翻译的密集指令可存储在存储器系统内并仅在刚要传给处理器核芯104之前才扩展成本机指令。
本例中的寄存器库106包含有16个通用32位寄存器，其中有四个被分配成用于存储栈操作数即用于存储栈操作数的成组寄存器是R0、R1、R2和R3。
所述成组寄存器可以是空的、部分地填充有栈操作数或完全填有栈操作数。当前保存栈顶操作数的特定寄存器可以是该组寄存器中的任何寄存器。因此，应该注意，指令翻译器可以处于十七种不同映射状态中的与所有寄存器都为空时的一种状态相对应的任何一种状态，并且，在成组寄存器中保存有四组每组都与相应不同数量的栈操作数相对应的四种状态，其中一个不同的寄存器保持着栈顶操作数。表1表明了用于指令翻译器108的状态映射的十七种不同的状态。应该注意，在有不同数量的寄存器分配给栈操作数存储装置的情况下，或者由于有特定的处理器核芯以能处理保存在寄存器内的数据值的方式所具有的限制，映射状态会明显地取决于特定的实现形式，表1仅是作为一种特定实现形式而给出的。
状态00000
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-3
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＝EMPTY    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-1
R3＝TOS      R3＝TOS        R3＝TOS      R3＝TOS
表1
在表1中，可以看出，状态值的头三位表示成组寄存器内非空寄存器数。状态值的最后两位表示保存栈顶操作数的寄存器的寄存器数。通过这种方式，状态值可以很容易地用于控制硬件翻译器或软件翻译器的操作，以便考虑到成组寄存器当前占用情况以及栈顶操作数的当前位置。
如图5所示，将Java字节流J1、J2、J3从可寻址的存储系统提供给指令翻译器。然后，指令翻译器108根据输入的Java字节码和指令翻译器8的瞬时映射状态以及其它变量输出ARM指令流(或等价的控制信号，也许是经扩展的)。所述的实例示出Java字节码J1被映射至ARM指令A11和A12。Java字节码J2映射至ARM指令A21、A22和A23。最后，Java字节码J3映射至ARM指令A31。每个Java字节码均需要一个或多个栈操作数作为输入并且产生一个或多个栈操作数作为输出。假定本例中的处理器核芯104是具有装载/存储结构的ARM处理器核芯因而仅可处理保持在寄存器中的数据值，则指令翻译器108设置成生成ARM指令，这些指令在需要时将任何需要的栈操作数在被处理之前取进成组的寄存器或者将成组寄存器中任何当前保存的栈操作数存储至可寻址的存储器，以便形成用于所生成的结果栈操作数的空间。应该注意，每个Java字节码可认为具有相关的“需要满”值和在一起的“需要空”值，前者表示在执行之前成组寄存器中必须存在的栈操作数的数量，而“需要空”值表示在执行代表Java操作码的ARM指令之前成组寄存器中必须有的空寄存器的数量。
表2说明了初始映射状态值、需要满值、最终状态值与相关ARM指令之间的关系。初始状态值和最终状态值对应于表1所述的映射状态。指令翻译器108确定与它正在翻译的特定Java字节码(操作码)相关的需要满值。指令翻译器(108)根据它所具有的初始映射状态确定是否有更多的栈操作数需要在执行Java字节码之前加载进成组寄存器。表1示出了初始状态以及用于Java字节码的需要满值的测试，它们一道用于确定是否需要用相关的ARM指令(LDR指令)和最终映射状态将栈操作数装载进成组寄存器，所述最终映射状态将在这种栈高速缓存装载操作之后加以采用。实际上，如果在执行Java字节码之前需要将一个以上的栈操作数装载进成组寄存器，则要进行多次映射状态转换，每次转换都伴随着相关的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字节码来说，只有需要满或需要空条件中的一个为真。指令翻译器108所使用的模板连同着选择该模板以便用硬件翻译器108来加以支持的指令一起被选择，从而使得能满足这种相互排斥的要求。如果这种要求是不适当的，则会出现这样的情形，其中，在执行表示Java字节码的指令以便使执行的结果按需保存在寄存器内之后，特定的Java字节码需要在不允许有足够的空寄存器的成组寄存器中存在多个输入栈操作数。
应该注意，给定的Java字节码具有表示执行该Java字节码时所消耗的栈操作数的数量与生成的栈操作数的数量之间平衡的总体的净栈活动。由于所消耗的栈操作数的数量是执行前的要求，所生成的栈操作数的数量是执行之后的要求，故即便基本的净活动自身得到满足，也必须在执行该字节码之前满足与各Java字节码相关的需要满和需要空值。表4说明了初始状态、总体栈活动、最终状态和寄存器使用变化与栈顶操作数(TOS)的相对位置之间的关系。需要在执行表4所述的状态转换之前执行一个或多个表2或表3所述的状态转换，以便根据Java字节码的需要满和需要空值对给定的Java字节码进行预处理。
初始     栈活动    最终      活动
状态               状态
00000    +1        00101     R1＜-TOS
00000    +2        01010     R1＜-TOS-1，R2＜-TOS
00000    +3        01111     R1＜-TOS-2，R2＜-TOS-1，R3＜-TOS
00000    +4        10000     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        O0000     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        00101     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    R0＜-EMPTY
01100    -2    00110    R0＜-EMPTY，R3＜-EMPTY
01100    -3    00000    R0＜-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
    栈：      ...，value1，value2＝＞
              ...，result
              Require-Full＝2
              Require-Empty＝0
              Stack-Action＝-1
    ---lload_0
    操作：        Load long from local variable
    栈：          ...＝＞
              ...，value.word1，value.word2
              Require-Full＝0
              Require-Empty＝2
              Stack-Action＝+2
    --- lastore
    操作：        Store into long array
栈：             ...，arrayref，index，value.word1，value.word2＝＞
             ...
             Require-Full＝4
             Require-Empty＝0
             Stack-Action＝-4
---land
操作：           Boolean AND long
栈：             ...，value1.word1，value1.word2，value2.word1，
value2.word2＝＞
             ...，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码指令的示例性指令模板。所示的指令是ARM指令，这些指令实现所需的各Java字节码的行为。在从表1中读出时根据当前采用的映射状态，寄存器域“TOS-3”、“TOS-1”、“TOS”、“TOS+1”和“TOS+2”可用适当的寄存器区分符来代替。标记“TOS+n”表示当前存储栈顶操作数的寄存器之上的第n个寄存器，它从存储栈顶操作数的寄存器开始并按寄存器值向上数直至到达成组寄存器尾部，在该点处，折返回到成组寄存器中的第一个寄存器。
    iconst_0               MOV         tos+1，#0
    lload_0                LDR         tos+2，[vars，#4]

                           LDR         tos+1，[vars，#0]
    iastore                LDR         Rtmp2，[tos-2，#4]

                           LDR         Rtmp1，[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-2，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
以下说明了依照上述技术的硬件翻译器108所执行的单个Java字节码的示例性执行顺序。执行顺序是从初始状态开始显示的，该状态根据正执行的指令经过一系列状态、由于在每一状态转换执行活动而生成一系列ARM指令，整个顺序具有将Java字节码翻译成一系列ARM指令的效果。
初始状态：                00000
指令：                    iadd(Require-Full＝2，Require-Empty＝0，Stack-Action＝-
1)
条件：            Require-Full＞0
状态转换：            00000    ＞0    00100
ARM指令(s)：
                                    LDR R0，[Rstack，#-4]！
下一状态：        00100
指令：                 iadd(Require-Full＝2，Require-Empty＝0，Stack-Action＝-
1)
条件  ：          Requite-Full＞1
状态转换  ：           00100      ＞1    01000
ARM指令(s)：
                                       LDR R3，[Rstack，#-4]！
下一状态：         01000
指令：                   iadd(Require-Full＝2，Require-Empty＝0，Stack-Action＝-
1)
条件：             Stack-Action＝-1
状态转换：         01000         -1    00111
指令模板：
                      ADD    tos-1，tos-1，tos
ARM指令(s)(替换之后)：
                                       ADD R3，R3，R0
下一状态：        00111
图6以不同的方式说明了执行多种其它Java字节码指令。图6的顶部说明了在执行iadd Java字节码指令时出现的ARM指令序列以及映射状态和寄存器内容的变化。初始映射状态是000000，它对应于成组寄存器中的所有寄存器均为空。所生成的头两个ARM指令用于将两个栈操作数弹(POP)至存储有栈操作数的寄存器，栈顶“TOS”寄存器为R0。第三个ARM指令实际执行加操作并将结果写至寄存器R3(它目前成为栈顶操作数)，同时使用先前保存在寄存器R1内的栈操作数，因此，产生的总体栈活动为-1。
然后，处理过程前进至执行两个Java字节码，每个字节码均表示两个栈操作数的长装载。用于第一Java字节码的为2的需要空条件可被立即满足，因此，可发出并执行两个ARM LDR指令。执行第一个长装载Java字节码之后的映射状态是01101。在这种状态下，成组寄存器仅含有单个空寄存器。下一个Java字节码长载指令具有为2的需要空值，它不能被满足，因此，所需要的第一动作用ARM STR指令起将栈操作数推(PUSH)至可寻址的存储器。这就能释放成组寄存器中的寄存器，以供可作为两个后续LDR指令的一部分而装载的新栈操作数使用。如前所述，可用硬件、软件或两者的结合来进行指令翻译。以下给出了根据上述技术生成的示例性软件解释器的一部分。
解释                 LDRB    Rtmp，[Rjpc，#1]！
                     LDR    pc，[pc，Rtmp，lsl #2]
                     DCD    0
                     ...
                     DCD    do_iconst_0    ；Opcode 0x03
                     ...
                     DCD    do_lload_0     ；Opcode 0xle
                     ...
                     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]
                           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！，{r0，r1}
                           B      Interpret
State_00000_Interpret      LDRB   Rtmp，[Rjpc，  #1]！
                           LDR    pc，[pc，Rtmp，1sl #2]
                           DCD    0
                           ...
                           DCD    State_00000_do_iconst_0  ；Opcode 0x03
                           ...
                           DCD    State_00000_do_lload_0   ；Opcode 0xle
                           ...
                           DCD    State_00000_do_iastore   ；Opcode 0x4f
                           ...
                           DCD    State_00000_do_lastore   ；Opcode 0x50
                           ...
                           DCD    State_00000_do_iadd      ；Opcode 0x60
                           ...
                           DCD    State_00000_do_ineg      ；Opcode 0x74
                           ...
                           DCD    State_00000_do_land      ；Opcode 0x7f
                           ...
State_00000_do_iconst_0    MOV    R1，#0
                           B      State_00101_Interpret
State_00000_do_lload_0     LDMIA  Rvars，{R1，R2}
                           B      State_01010_Interpret
State_00000_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]
                          B          State_00000_Interpret
State_00000_do_lastore    LDMDB      Rstack！，{R0，R1，R2，R3}
                          LDR        Rtmp2，[r0，#4]
                          LDR        Rtmp1，[r0，#0]
                          CMP        R1，Rtmp2，LSR #5
                          BCS        Array Bound Exception
                          STR        R2，[Rtmp1，R1，LSL #3]！
                          STR        R3，[Rtmp1，#4]
                          B          State_00000_Interpret
State_00000_do_iadd       LDMDB      Rstack！，{R1，R2}
                          ADD        r1，r1，r2
                          B          State_00101_Interpret
State_00000_do_ineg       LDR        r1，[Rstack，#-4]！
                          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_do_lload_0  ；Opcode 0xle
                          ...
                          DCD        State_00100_do_iastore  ；Opcode 0x4f
                          DCD        State_00100_do_lastore  ；Opcode 0x50
                          ...
                          DCD        State_00100_do_iadd     ；Opcode 0x60
                          ...
                          DCD        State_00100_do_ineg     ；Opcode 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]
                          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        ArrayBoundException
                          STR        r3，[Rtmpl，r2，lsl #3]！
                          STR        r0，[Rtmpl，#4]
                          B        State_00000_Interpret
State_00100_do_iadd       LDR      r3，[Rstack，#-4]！
                          ADD      r3，r3，r0
                          B        State_00111_Interpret
State_00100_do_ineg       RSB      r0，r0，#0
                          B        State_00100_Interpret
State_00100_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 ；Opcode 0xle
                          ...
                          DCD      State_01000_do_iastore ；Opcode 0x4f
                          DCD      State_01000_do_lastore ；Opcode 0x50
                          ...
                          DCD      State_01000_do_iadd    ；Opcode 0x60
                          ...
                          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      Rtmp2，[R3，#4]
                          LDR      Rtmp1，[R3，#0]
                          CMP      r0，Rtmp2，LSR #5
                          BCS      ArrayBoundException
                          STR      r1，[Rtmp1，r0，lsl #2]
                          B        State_00000_Interpret
State_01000_do_lastore    LDMDB    Rstack！，{r1，r2}
                          LDR      Rtmp2，{r3，#4}
                          LDR      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
                          B        State_01000_Interpret
State_01100_Interpret     ...
State_10000_Interpret     ...
State_00101_Interpret     ...
State_01001_Interpret     ...
State_01101_Interpret     ...
State_10001_Interpret    ...
State_00110_Interpret    ...
State_01010_Interpret    ...
State_01110_Interpret    ...
State_10010_Interpret    ...
State_00111_Interpret    ...
State_01011_Interpret    ...
State_01111_Interpret    ...
State_10011_Interpret    ...
图7说明了Java字节码指令“laload”，它具有从始于找顶位置的数据的两个字所指定的数据阵列中读出数据的两个字的功能。从数据阵列中读出的两个字代替指定它们位置的两个字，以便形成最顶部的栈入口。
为了使得“laload”指令具有足够的寄存器空间以用于存储从所述阵列中取出的栈操作数而不会重写用于指定数据阵列中的阵列和位置的输入栈操作数，Java字节码指令被指定为具有为2的需要空值，也就是说，必须在执行模仿“laload”指令的ARM指令之前，清空栈操作数存储所专用的寄存器中的两个寄存器。如果在遇到所述Java字节码时不存在有两个空的寄存器，则可执行存储操作(STR)，以便将当前保存在寄存器内的栈操作数推(PUSH)出至存储器，从而形成用于暂时存储所需的空间并满足用于所述指令的需要空值。
当阵列中的阵列位置和下标作为两个独立的栈操数而指定了数据的位置时，所述指令还具有为2的需要满值。附图说明了在已经满足了需要满和需要空条件时并具有为“01001”的映射状态的第一状态。将“laload”指令分成三个ARM指令。第一个指令将阵列基准装载进成组寄存器以外的备用工作寄存器，该寄存器起栈操作数的寄存器高速缓存的作用。第二个指令用所述阵列基准以及阵列中的下标值去访问第一阵列字，该阵列字被写至栈操作数存储所专用的空寄存器之一内。
值得注意的是，在执行了上述头两ARM指令之后，系统的映射状态并未改变，栈顶指针仍保持在该寄存器被指定为空面如此规定的开始位置上。
ARM指令序列中的最后一个指令将第二阵列字装载进用于存储找操作数的成组寄存器中。由于这是最后一个指令，如果其间真的出现中断，则该中断不会得到响应直至该指令结束，所以通过改变到存储栈操作数的寄存器的映射状态而改变此指令的输入状态是安全的。在本例中，映射状态改变成“01011”，这种状态将新的栈顶指针置于第二阵列字并指明阵列的基准和下标值的输入变量目前是空寄存器，也就是说，将寄存器标记为空等价于从栈中除去这些寄存器所保存的值。
应该注意，尽管“laload”指令的总体栈活动尚未改变寄存器中所保存的栈操作数的数量，但仍会发生映射状态的交换。在执行最后操作时的映射状态的改变是作为所翻译的Java字节码的功能而硬连线至指令翻译器并由被显示为“laload”指令特征的“交换”参数来表明的。
尽管附图中的实例是一个特定的指令，但是，应该注意，所述的原理可扩展至被模拟为ARM指令或其它类型指令的多种不同的Java字节码。
图8是概略说明上述技术的流程图。在步骤10，从存储器中取出Java字节码。在步骤12，检验用于该Java字节码的需要满和需要空值。如果未满足需要空或需要满条件中的任何一个，则用步骤14和16执行栈操作数(可能为多个栈操作数)的相应PUSH和POP操作。应该注意，这种特定的系统不允许同时不满足需要空和需要满条件。需要多次进行步骤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还概略地说明了有确定的中断并得到响应时的点以及在中断之后重启动的处理过程。在执行了当前于步骤22中进行的ARM指令之后，中断开始得到响应而不管作为字节码序列返回值而存储起来的当前程序计数器值是什么。如果当前执行的ARM指令是模板序列中的最后一个指令，则步骤21会刚好更新完程序计数器值，因此，该计数器值会指向下一个Java字节码(或ARM指令，如果是指令集转换刚开始的情况下)。如果当前执行的ARM指令是除所述序列中最后一个指令以外的任何一个指令，则程序计数器值与在开始执行相关Java字节码时所指明的值相同，因此，在返回时，会重新执行整个的Java字节码。
图9说明了Java字节码翻译器68，它接收Java字节码流并输出所翻译的ARM指令流(或相应的控制信号)，以控制处理器核芯的活动。如前所述，Java字节码翻译器68将使用指令模板将简单Java字节码翻译成ARM指令或ARM指令序列。当已执行各Java字节码时，调度控制逻辑电路70中的计数器值递减。当该计数器值达到0时，Java字节码翻译器68将发出ARM指令以分支到调度代码，该代码适当地管理线程或任务之间的调度。
尽管由Java字节码翻译器68本身来处理简单的Java字节码可以用硬件为基础高速执行这些字节码，但是，可将需要更复杂处理操作的字节码发送给软件解释器，该解释器呈一组解释例程的形式(以上在本说明书中给出了这一类例程的实例)。具体地说，Java字节码翻译器68可确定它所接收的字节码不是由硬件翻译来支持的字节码，因此，可根据Java字节码分支转换至这样的地址，在该地址处，发现或引用用于对该字节码进行解释的软件例程。在调度逻辑电路70指示需要调度操作来对调度代码产生分支时，也可以使用这种机制。
图10更详细地说明了图9的实施例的操作以及硬件与软件之间的任务分解。所有的Java字节码均由Java字节码翻译器68来接收并且在步骤72使计数器递减。在步骤74，检查计数器值是否达到0。如果计数器值已达到0(从与系统硬连线所预定的值或可由用户控制/编程的值开始递减计数)，则在步骤76转移到调度代码。一旦在步骤76完成了调度代码，则控制权返回至硬件，处理过程前进至步骤72，在该步骤处，取出下一个Java字节码，计数值再再递减。由于计数器值达到0，则它会循环至新的非零值。或者，在步骤76，新值可作为现存调度过程的一部分强制送入计数器。
如果步骤74的测试表明计数器不等于0，则步骤78取出Java字节码。在步骤80，判断所取出的字节码是可以由步骤82的硬件翻译所执行的简单字节码还是需要更复杂的处理因此应加以传送以便在步骤84作软件解释的字节码。如果处理是传送到软件解释去的，则一且完成，控制权就返回至硬件，在硬件中，步骤72再次使计数器递减，以便考虑取出下一个Java字节码。
图11说明了另一种控制结构。在步骤86的处理过程的开始，去除对指令信号(调度信号)的确认。在步骤88，检查取出的Java字节码以确认该字节码是否是支持硬件翻译的简单字节码。如果不支持硬件翻译，则控制权在步骤90传给解释软件，然后该软件执行ARM例程以解释Java字节码。如果字节码是支持硬件翻译的简单字节码，则处理过程前进至步骤92，在该步骤，以多循环有限状态机形式工作的Java字节码翻译器68按顺序发出一个或多个ARM指令。一旦在步骤90或步骤92适当地执行了Java字节码，则处理过程前进至步骤94，在该步骤，在步骤86解除确认之前在短时间段内确认该指令信号。对指令信号的确认是向外部电路表示已达到适当的安全点，在这种安全点，可以产生基于计时器的调度中断而不会因部分地执行中断或翻译的指令而损失数据的完整性。
图12说明了可用于响应图11所生成的指令信号的示例性电路。计时器76在给定时间周期结束之后周期性生成计时器信号。这种计时器信号存储在锁存器98内，直至锁存器被清空计时器中断信号所清空。锁存器98的输出由AND(与)门100在逻辑上与在步骤94确认的指令信号相结合。当锁存器置位并指令信号被确认时，作为AND门100的输出产生一中断，该中断用来触发利用系统中设置的用于标准中断处理的中断处理机制来执行调度操作的中断。一旦生成了中断信号，则该信号又会触发产生清空计时器中断信号，它清空锁存器98，直至下一个计时器输出脉冲出现。
图13是说明图12的电路操作的信号图。处理器核芯时钟信号按规则的频率出现。计时器96按预定的周期生成计时器信号，以指示在安全时开始调度操作。计时器信号被锁存。用一定间隔分隔开的时间生成指令信号，所述间隔取决于何等快速地执行特定的Java字节码。简单Java字节码可在单个处理器核芯时钟周期或更一般地为两个或三个的多个周期内执行，而提供高层管理类型功能的复杂Java字节码则在其执行由软件解释器完成之前要花费数百个处理器时钟周期。在每一种情况下，挂起的确认锁存计时器信号都不会起作用去触发调度操作，直至指令信号指明开始调度操作是安全的。锁存的计时器信号和指令信号的同时出现会触发产生中断信号，其后紧跟着清空锁存器98的清空信号。

Claims (25)

1.用于处理数据的设备，该设备包括：
一处理器核芯，它可执行第一指令集的指令所指定的操作，所述处理器核芯具有这样的指令流水线，它可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进；以及
一指令翻译器，它可将第二指令集的指令翻译成与第一指令集的指令相对应的翻译器输出信号；其中，
所述指令翻译器位于上述指令流水线内并翻译业已被从前述存储器中取至所述指令流水线内的第二指令集的指令；
所述第二指令集的至少一个指令指定了一个需要多个操作的多步操作，所述多个操作可由第一指令集的指令来指定，以便由前述处理器核芯来加以执行；以及
所述指令翻译器可生成翻译器输出信号序列，以便控制前述处理器核芯去执行上述多步操作。
2.如权利要求1的设备，其特征在于，所述翻译器输出信号包括构成前述第一指令集的指令的信号。
3.如权利要求1和2中的任何一项的设备，其特征在于，所述翻译器输出信号包括控制信号，这些信号控制所述处理器核芯的操作并与在对前述第一指令集的指令进行解码时产生的控制信号相匹配。
4.如权利要求1、2和3中任何一项的设备，其特征在于，所述翻译器输出信号包括控制信号，这些信号控制所述处理器核芯的操作并指定未被在对前述第一指令集的指令进行解码时产生的控制信号所指定的参数。
5.如前述权利要求中任何一项的设备，其特征在于，所述处理器核芯从前述存储器内由程序计数器值所指定的指令地址处取出指令，所述程序计数器值保存在上述处理器核芯内。
6.如权利要求5的设备，其特征在于，在执行所述第二指令集的指令时，所述程序计数器值的增加量与第二指令集的指令是否指定多步操作无关。
7.如权利要求5和6中任何一项的设备，其特征在于，在执行所述第二指令集的指令时，所述程序计数器值增加以指定要加以执行的第二指令集的下一个指令。
8.如权利要求5、6和7中任何一项的设备，其特征在于，如果在执行所述第二指令集的指令时出现中断，就保存所述程序计数器值，该值用于在上述中断之后重新开始执行第二指令集的所述指令。
9.如前述权利要求中任何一项的设备，其特征在于，所述第二指令集的指令规定了要对保存在栈内的栈操作数执行的操作。
10.如前述权利要求中任何一项的设备，其特征在于，所述处理器具有寄存器库，它包含有多个寄存器，所述第一指令集的指令对保存在上述寄存器内的寄存器操作数执行操作。
11.如权利要求10的设备，其特征在于，所述寄存器库中的一组寄存器保存着来自前述堆栈顶部的栈操作数。
12.如权利要求9和11的设备，其特征在于，所述指令翻译器具有多种映射状态，其中，上述成组寄存器中的不同寄存器保存来自所述堆栈中不同位置的相应栈操作数，所述指令翻译器可根据增加或去掉保存在上述堆栈中的栈操作数而在映射状态之间移动。
13.如前述权利要求中任何一个的设备，其特征在于，该设备还包括所述指令流水线内的旁通通路，因此，在所述第二指令集的指令未被处理时可绕过所述指令翻译器。
14.如前述权利要求中任何一个的设备，其特征在于，所述第二指令集的指令是Java虚拟机字节码。
15.一种用带有指令流水线的处理器核芯来处理数据的方法，要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进，所述处理器核芯能执行第一指令集所指定的操作，所述方法包括下列步骤：
将指令取至上述指令流水线；以及
用前述指令流水线中的指令翻译器将取出的第二指令集的指令翻译成与上述第一指令集的指令相对应的翻译器输出信号；其中
所述第二指令集的至少一个指令指定了一需要多个操作的多步操作，所述多个操作可由前述第一指令集来指定，以便由上述处理器核芯执行；以及
所述指令翻译器可生成一系列翻译器输出，以便控制上述处理器核芯，从而执行前述多步操作。
16.一种计算机程序产品，它存放计算机程序，以控制计算机执行权利要求13的方法。
17.用于处理数据的设备，该设备包括：
一处理器核芯，它可执行第一指令集的指令所指定的操作，所述处理器核芯具有这样的指令流水线，可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进；以及
一指令翻译器，它可将第二指令集的指令翻译成与第一指令集的指令相对应的翻译器输出信号；其中，
所述第二指令集的上述指令是变长指令；
所述指令翻译器位于上述指令流水线内并翻译业已从前述存储器中在取阶段取至所述指令流水线的第二指令集的指令；
所述指令流水线的取阶段包括一指令缓存，它存放着从所述存储器中取出的至少一个当前指令字以及下一个指令字，因此，若所述第二指令集的变长指令在前述当前指令字内开始并延伸至所述下一个指令字，则该下一个指令字可在上述流水线内获得，以便在不需要另外的取操作的情况下由所述指令翻译器来翻译。
18.如权利要求17的设备，其特征在于，所述指令字缓存是摆动缓存。
19.如权利要求17和18中的任何一项设备，其特征在于，所述取阶段包括多个多路复用器，它们用于从一个或多个所述当前指令字和下一个指令字中选择变长指令。
20.如权利要求17、18和19中的任何一项设备，其特征在于，所述第二指令集的指令是Java虚拟机字节码。
21.如权利要求17至20中的任何一项设备，其特征在于，该设备还包括所述指令流水线内的旁通通路，因此，在所述第二指令集的指令未作处理时可绕过所述指令翻译器。
22.如权利要求17至21中的任何一项设备，其特征在于，
所述第二指令集的至少一个指令指定了需要多个操作的多步操作，所述多个操作可由前述第一指令集来指定，以便由上述处理器核芯执行；以及
所述指令翻译器可生成一系列翻译器输出，以便控制上述处理器核芯去执行前述多步操作。
23.如权利要求22以及如权利要求2至12中的任何一项设备。
24.用能执行第一指令集所指定的操作的处理器核芯来处理数据的方法，所述处理器核芯具有这样的指令流水线，可将要执行的指令从存储器取至该流水线，并且，指令沿该流水线前进，所述方法包括下列步骤：
将指令取至上述指令流水线；以及
用所述指令流水线内的指令翻译器将取出的第二指令集的指令翻译成与第一指令集的指令相对应的翻译器输出信号；其中，
所述第二指令集的所述指令是变长指令；
所述指令翻译器位于上述指令流水线内并翻译业已从前述存储器中在取阶段取至所述指令流水线的第二指令；以及
所述指令流水线的取阶段包括一指令缓存，它存放着从所述存储器中取出的至少一个当前指令字以及下一个指令字，因此，若所述第二指令集的变长指令在前述当前指令字内开始并延伸至所述下一个指令字，则该下一个指令字可在上述流水线内获得，以便在不需要另外的取操作的情况下由所述指令翻译器来翻译。
25.一种计算机程序产品，它保存计算机程序，以便控制计算机来执行权利要求24的方法。
CNA018200931A 2000-10-05 2001-06-21 处理器流水线中的硬件指令翻译 Pending CN1484787A (zh)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
GB0024396A GB2367651B (en) 2000-10-05 2000-10-05 Hardware instruction translation within a processor pipeline
GB0024396.4 2000-10-05

Publications (1)

Publication Number Publication Date
CN1484787A true CN1484787A (zh) 2004-03-24

Family

ID=9900734

Family Applications (1)

Application Number Title Priority Date Filing Date
CNA018200931A Pending CN1484787A (zh) 2000-10-05 2001-06-21 处理器流水线中的硬件指令翻译

Country Status (9)

Country Link
US (1) US20020083302A1 (zh)
EP (1) EP1330691A2 (zh)
JP (1) JP2004522215A (zh)
KR (1) KR20030040515A (zh)
CN (1) CN1484787A (zh)
GB (1) GB2367651B (zh)
IL (1) IL154956A0 (zh)
RU (1) RU2003112679A (zh)
WO (1) WO2002029507A2 (zh)

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101304312B (zh) * 2008-06-26 2011-07-20 复旦大学 一种适用于精简指令集处理器的加密单元
CN102207848A (zh) * 2010-03-29 2011-10-05 索尼公司 指令取回装置、处理器和程序计数器加法控制方法
CN102037448B (zh) * 2008-05-23 2014-04-02 Arm有限公司 主机数据处理设备内的装置仿真支持
CN105373414A (zh) * 2014-08-26 2016-03-02 龙芯中科技术有限公司 支持MIPS平台的Java虚拟机实现方法及装置
CN109564547A (zh) * 2016-08-19 2019-04-02 Arm有限公司 存储器单元和存储器单元处理操作请求的操作方法
CN110704108A (zh) * 2019-08-30 2020-01-17 阿里巴巴集团控股有限公司 解释执行字节码指令流的方法及装置
US10802854B2 (en) 2019-08-30 2020-10-13 Alibaba Group Holding Limited Method and apparatus for interpreting bytecode instruction stream

Families Citing this family (18)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
GB2393270B (en) 2002-09-19 2005-07-27 Advanced Risc Mach Ltd Executing variable length instructions stored within a plurality of discrete memory address regions
US7769983B2 (en) * 2005-05-18 2010-08-03 Qualcomm Incorporated Caching instructions for a multiple-state processor
JP2007122626A (ja) * 2005-10-31 2007-05-17 Matsushita Electric Ind Co Ltd マイクロプロセッサ
US7711927B2 (en) * 2007-03-14 2010-05-04 Qualcomm Incorporated System, method and software to preload instructions from an instruction set other than one currently executing
US8195923B2 (en) * 2009-04-07 2012-06-05 Oracle America, Inc. Methods and mechanisms to support multiple features for a number of opcodes
FR2969787B1 (fr) * 2010-12-24 2013-01-18 Morpho Protection des applets
WO2012103359A2 (en) 2011-01-27 2012-08-02 Soft Machines, Inc. Hardware acceleration components for translating guest instructions to native instructions
WO2012103209A2 (en) 2011-01-27 2012-08-02 Soft Machines, Inc. Guest instruction to native instruction range based mapping using a conversion look aside buffer of a processor
WO2012103253A2 (en) 2011-01-27 2012-08-02 Soft Machines, Inc. Multilevel conversion table cache for translating guest instructions to native instructions
WO2012103245A2 (en) 2011-01-27 2012-08-02 Soft Machines Inc. Guest instruction block with near branching and far branching sequence construction to native instruction block
WO2012103367A2 (en) * 2011-01-27 2012-08-02 Soft Machines, Inc. Guest to native block address mappings and management of native code storage
WO2012103373A2 (en) 2011-01-27 2012-08-02 Soft Machines, Inc. Variable caching structure for managing physical storage
WO2013132767A1 (ja) 2012-03-09 2013-09-12 パナソニック株式会社 プロセッサ、マルチプロセッサシステム、コンパイラ、ソフトウェアシステム、メモリ制御システムおよびコンピュータシステム
WO2014151652A1 (en) 2013-03-15 2014-09-25 Soft Machines Inc Method and apparatus to allow early dependency resolution and data forwarding in a microprocessor
EP2972798B1 (en) 2013-03-15 2020-06-17 Intel Corporation Method and apparatus for guest return address stack emulation supporting speculation
US20140281398A1 (en) * 2013-03-16 2014-09-18 William C. Rash Instruction emulation processors, methods, and systems
US9703562B2 (en) * 2013-03-16 2017-07-11 Intel Corporation Instruction emulation processors, methods, and systems
GB2514618B (en) * 2013-05-31 2020-11-11 Advanced Risc Mach Ltd Data processing systems

Family Cites Families (23)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US3955180A (en) * 1974-01-02 1976-05-04 Honeywell Information Systems Inc. Table driven emulation system
CA1271561A (en) * 1986-07-02 1990-07-10 Jeffry M. Bram Instruction decoding microengines
US5432795A (en) * 1991-03-07 1995-07-11 Digital Equipment Corporation System for reporting errors of a translated program and using a boundry instruction bitmap to determine the corresponding instruction address in a source program
GB2263985B (en) * 1992-02-06 1995-06-14 Intel Corp Two stage window multiplexors for deriving variable length instructions from a stream of instructions
US5367685A (en) * 1992-12-22 1994-11-22 Firstperson, Inc. Method and apparatus for resolving data references in generated code
US5781750A (en) * 1994-01-11 1998-07-14 Exponential Technology, Inc. Dual-instruction-set architecture CPU with hidden software emulation mode
GB2289354B (en) * 1994-05-03 1997-08-27 Advanced Risc Mach Ltd Multiple instruction set mapping
GB2290395B (en) * 1994-06-10 1997-05-28 Advanced Risc Mach Ltd Interoperability with multiple instruction sets
US5598546A (en) * 1994-08-31 1997-01-28 Exponential Technology, Inc. Dual-architecture super-scalar pipeline
US5640526A (en) * 1994-12-21 1997-06-17 International Business Machines Corporation Superscaler instruction pipeline having boundary indentification logic for variable length instructions
US5619665A (en) * 1995-04-13 1997-04-08 Intrnational Business Machines Corporation Method and apparatus for the transparent emulation of an existing instruction-set architecture by an arbitrary underlying instruction-set architecture
US5826089A (en) * 1996-01-04 1998-10-20 Advanced Micro Devices, Inc. Instruction translation unit configured to translate from a first instruction set to a second instruction set
US5970242A (en) * 1996-01-24 1999-10-19 Sun Microsystems, Inc. Replicating code to eliminate a level of indirection during execution of an object oriented computer program
US5802373A (en) * 1996-01-29 1998-09-01 Digital Equipment Corporation Method for providing a pipeline interpreter for a variable length instruction set
US5805895A (en) * 1996-06-09 1998-09-08 Motorola, Inc. Method and apparatus for code translation optimization
US5909567A (en) * 1997-02-28 1999-06-01 Advanced Micro Devices, Inc. Apparatus and method for native mode processing in a RISC-based CISC processor
US5898885A (en) * 1997-03-31 1999-04-27 International Business Machines Corporation Method and system for executing a non-native stack-based instruction within a computer system
US5953520A (en) * 1997-09-22 1999-09-14 International Business Machines Corporation Address translation buffer for data processing system emulation mode
EP0950216B1 (en) * 1997-10-02 2003-11-26 Koninklijke Philips Electronics N.V. A processing device for executing virtual machine instructions
AU745449B2 (en) * 1997-11-20 2002-03-21 Hajime Seki Computer system
US6012138A (en) * 1997-12-19 2000-01-04 Lsi Logic Corporation Dynamically variable length CPU pipeline for efficiently executing two instruction sets
US6249861B1 (en) * 1998-12-03 2001-06-19 Sun Microsystems, Inc. Instruction fetch unit aligner for a non-power of two size VLIW instruction
US6332215B1 (en) * 1998-12-08 2001-12-18 Nazomi Communications, Inc. Java virtual machine hardware for RISC and CISC processors

Cited By (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN102037448B (zh) * 2008-05-23 2014-04-02 Arm有限公司 主机数据处理设备内的装置仿真支持
CN101304312B (zh) * 2008-06-26 2011-07-20 复旦大学 一种适用于精简指令集处理器的加密单元
CN102207848A (zh) * 2010-03-29 2011-10-05 索尼公司 指令取回装置、处理器和程序计数器加法控制方法
CN105373414A (zh) * 2014-08-26 2016-03-02 龙芯中科技术有限公司 支持MIPS平台的Java虚拟机实现方法及装置
CN105373414B (zh) * 2014-08-26 2018-11-20 龙芯中科技术有限公司 支持MIPS平台的Java虚拟机实现方法及装置
CN109564547A (zh) * 2016-08-19 2019-04-02 Arm有限公司 存储器单元和存储器单元处理操作请求的操作方法
CN109564547B (zh) * 2016-08-19 2023-04-25 Arm有限公司 存储器单元和存储器单元处理操作请求的操作方法
CN110704108A (zh) * 2019-08-30 2020-01-17 阿里巴巴集团控股有限公司 解释执行字节码指令流的方法及装置
US10802854B2 (en) 2019-08-30 2020-10-13 Alibaba Group Holding Limited Method and apparatus for interpreting bytecode instruction stream

Also Published As

Publication number Publication date
KR20030040515A (ko) 2003-05-22
WO2002029507A2 (en) 2002-04-11
US20020083302A1 (en) 2002-06-27
GB2367651B (en) 2004-12-29
GB2367651A (en) 2002-04-10
IL154956A0 (en) 2003-10-31
RU2003112679A (ru) 2004-11-27
JP2004522215A (ja) 2004-07-22
GB0024396D0 (en) 2000-11-22
EP1330691A2 (en) 2003-07-30
WO2002029507A3 (en) 2003-05-22

Similar Documents

Publication Publication Date Title
CN1287270C (zh) 重启动翻译的指令
CN1244051C (zh) 对于处理数据的装置和方法
CN1484787A (zh) 处理器流水线中的硬件指令翻译
CN1135468C (zh) 对存储设备中信号数据字执行数字信号处理的方法和装置
CN1103961C (zh) 协处理器的数据访问控制装置和方法
CN1584824A (zh) 一种基于cisc结构的微处理器构架及指令实现方式
CN1236380C (zh) 具随机数产生器及用于存储随机数数据的指令的微处理器
CN1427335A (zh) 电路组控制系统
CN1027198C (zh) 计算装置
CN1021380C (zh) 计算系统的命令传递
CN1625731A (zh) 具有多种长度指令集体系结构的可配置数据处理器
CN1860441A (zh) 用于可重新配置环境中的高效高性能数据操作元件
CN1269052C (zh) 支持缩小代码长度的常量还原型处理器
CN1702634A (zh) 便利无环境主机干预下的可分页模式虚拟环境存储管理
CN1641567A (zh) 自堆栈快取存储器进行快速推测性弹出操作方法及装置
CN1728685A (zh) 促进可分页模式虚拟环境中的数据传输的方法和系统
CN1469241A (zh) 处理器、程序变换装置和变换方法以及计算机程序
CN1226323A (zh) 数据处理装置寄存器
CN1103959C (zh) 数据处理装置和操作数据处理装置的方法
CN1137421C (zh) 可编程控制器
CN1503128A (zh) 具有支持多任务运算的随机数产生器的微处理器及方法
CN1516001A (zh) 一种新型risc流水线微控制器构架及其操作方法
CN1310131C (zh) 随机数产生器及产生方法及具有随机位产生器的微处理器
CN1104679C (zh) 数据处理装置和数据处理方法
CN1226325A (zh) 数据处理系统中的输入操作数控制

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
C02 Deemed withdrawal of patent application after publication (patent law 2001)
WD01 Invention patent application deemed withdrawn after publication