JP2008536240A - Microprocessor access using native instructions to the operand stack as a register file - Google Patents

Microprocessor access using native instructions to the operand stack as a register file Download PDF

Info

Publication number
JP2008536240A
JP2008536240A JP2008506461A JP2008506461A JP2008536240A JP 2008536240 A JP2008536240 A JP 2008536240A JP 2008506461 A JP2008506461 A JP 2008506461A JP 2008506461 A JP2008506461 A JP 2008506461A JP 2008536240 A JP2008536240 A JP 2008536240A
Authority
JP
Japan
Prior art keywords
java
register
instructions
native
microprocessor
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.)
Abandoned
Application number
JP2008506461A
Other languages
Japanese (ja)
Inventor
ストロム，オイビンド
レノ，エリク
モンセン，クリスティアン
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.)
Atmel Corp
Original Assignee
Atmel Corp
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 Atmel Corp filed Critical Atmel Corp
Publication of JP2008536240A publication Critical patent/JP2008536240A/en
Abandoned 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
    • 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/3012—Organisation of register space, e.g. banked or distributed register file
    • G06F9/30134—Register stacks; shift registers
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F13/00—Interconnection of, or transfer of information or other signals between, memories, input/output devices or central processing units
    • G06F13/10—Program control for peripheral devices
    • G06F13/12—Program control for peripheral devices using hardware independent of the central processor, e.g. channel or peripheral processor
    • G06F13/124—Program control for peripheral devices using hardware independent of the central processor, e.g. channel or peripheral processor where hardware is a sequential transfer control unit, e.g. microprocessor, peripheral processor or state-machine
    • 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
    • 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/30181—Instruction operation extension or modification
    • G06F9/30196—Instruction operation extension or modification using decoder, e.g. decoder per instruction set, adaptable or programmable decoders
    • 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/32—Address formation of the next instruction, e.g. by incrementing the instruction counter
    • G06F9/321—Program or instruction counter, e.g. incrementing
    • 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

Landscapes

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

Abstract

結合されたネイティブ（ＲＩＳＣまたはＣＩＳＣ）マイクロプロセッサおよびスタック（Ｊａｖａ（登録商標））マシン（１０，１１，１３）は、Ｊａｖａ（登録商標）ＶＭ命令がハードウェアで実行され得るように構築される。ほとんどのＪａｖａ（登録商標）命令は直接実行され（５４）、その一方でより複雑なＪａｖａ（登録商標）命令、たとえばＪａｖａ（登録商標）オブジェクトを操作する命令はネイティブマイクロコード（５６）として実行される。ネイティブマイクロコード命令がＪａｖａ（登録商標）オペランドスタックにアクセスするために、Ｊａｖａ（登録商標）オペランドスタックポインタ（２２，１０２）が、現在のスタックトップ（ＴｏＳ）であるレジスタファイル（１５，９０）位置を指定する一方、状態レジスタ（１０１）の再マップビット（ＲＭ）は、ネイティブ命令において特定されるレジスタが、Ｊａｖａ（登録商標）オペランドスタックポインタ最大値からＪａｖａ（登録商標）オペランドスタックポインタの現在の値を引き算したものとして再マップされる（９０ａ）ことを表わす。  The combined native (RISC or CISC) microprocessor and stack (Java®) machine (10, 11, 13) are constructed so that Java® VM instructions can be executed in hardware. Most Java instructions are executed directly (54), while more complex Java instructions, such as instructions that operate on Java objects, are executed as native microcode (56). The Register file (15, 90) location where the Java (registered trademark) operand stack pointer (22, 102) is the current stack top (ToS) for native microcode instructions to access the Java (registered trademark) operand stack The remapping bit (RM) of the status register (101) indicates that the register specified in the native instruction is the current value of the Java (registered trademark) operand stack pointer from the maximum value of the Java (registered trademark) operand stack pointer. Remapping as a value subtracted (90a).

Description

技術分野
この発明は、メモリ指向のアーキテクチャを備えたマイクロプロセッサ（たとえば複数命令セットコンピュータすなわちＣＩＳＣマシン）およびロード・ストアアーキテクチャを備えたマイクロプロセッサ（たとえば縮小命令セットコンピュータ、すなわちＲＩＳＣマシン）を含むマイクロプロセッサ、ならびにＪａｖａ（登録商標）仮想マシンコアアーキテクチャを有するものを含むスタックマシンの、レジスタファイルスタックへのアクセスに関する。ＲＩＳＣまたはＣＩＳＣ状態およびＪａｖａ（登録商標）状態でも動作可能な結合アーキテクチャが特に適切である。より特定的には、この発明は、ＲＩＳＣ状態からＪａｖａ（登録商標）オペランドスタックにアクセスするなどの、アーキテクチャにネイティブな命令を用いてオペランドスタックにアクセスすることに関する。 TECHNICAL FIELD This invention relates to a microprocessor comprising a microprocessor (eg, a multiple instruction set computer or CISC machine) with a memory-oriented architecture and a microprocessor (eg, a reduced instruction set computer or RISC machine) with a load store architecture. , As well as access to the register file stack of stack machines, including those having the Java virtual machine core architecture. Particularly suitable is a combined architecture that can also operate in RISC or CISC state and Java state. More specifically, the present invention relates to accessing an operand stack using architecture native instructions, such as accessing a Java operand stack from a RISC state.

背景技術
マイクロプロセッサはいくつかの基本カテゴリに分類することができる。スタックマシンでは、すべての算術論理演算装置（ＡＬＵ）演算がオペランドスタックの最上位のレジスタで行われる。ＣＩＳＣマシンではメモリにおいて直接演算が行われる（すなわち、オペランドはメモリからアクセスされ、結果がメモリに格納される）。ＲＩＳＣマシンでは、中央処理装置（ＣＰＵ）に存在するアドレス可能なレジスタ上ですべての演算が実行される。初期のマイクロプロセッサはスタックマシンであったが、今日ではほとんどのマイクロプロセッサはＣＩＳＣまたはＲＩＳＣマシンのいずれかである。時間とともにＣＩＳＣマシンとＲＩＳＣマシンとは設計において互いに近づき、最も近代のＣＩＳＣマシンもまた演算が実行されるレジスタファイルを有する。サンマイクロシステムズ（Sun Microsystems）によるＪａｖａ（登録商標）プログラミング言語およびＪａｖａ（登録商標）仮想マシン（Ｊａｖａ（登録商標）ＶＭ）の採用により、近代のマイクロプロセッサにスタックマシンが再び採用された。Ｊａｖａ（登録商標）ＶＭがソフトウェアとして動くように本来意図されていたにもかかわらず、ハードウェアによる実現例もいくつか存在する。 Microprocessors can be divided into several basic categories. In a stack machine, all arithmetic logic unit (ALU) operations are performed on the top register of the operand stack. In a CISC machine, operations are performed directly in memory (ie, operands are accessed from memory and results are stored in memory). In a RISC machine, all operations are performed on addressable registers residing in a central processing unit (CPU). Early microprocessors were stack machines, but today most microprocessors are either CISC or RISC machines. Over time, CISC machines and RISC machines approach each other in design, and most modern CISC machines also have register files on which operations are performed. With the adoption of the Java® programming language and Java® virtual machine (Java® VM) by Sun Microsystems, stack machines have again been adopted for modern microprocessors. Although the Java (registered trademark) VM was originally intended to run as software, there are several hardware implementations.

サンマイクロシステムズによって開発されたＪａｖａ（登録商標）はオブジェクト指向のプログラミング言語であってネットワークプログラミングにおけるデファクトスタンダードになっており、さらに組込システムの分野でも利用され始めている。Ｊａｖａ（登録商標）バイトコードは、Ｊａｖａ（登録商標）仮想マシンと呼ばれるソフトウェア層において一般に実行され、その仕様はサンマイクロシステムズによって発行されている。Ｊａｖａ（登録商標）バイトコードを実行するためには、好ましくは、潜在的なプログラムフローのボトルネックを分析するための何らかの形の先読み技術と関連して、インタープリタもしくは「ジャスト・イン・タイム」コンパイラ、または特定のハードウェアプラットフォームのためのクロスコンパイラが用いられ得る。代替的には、Ｊａｖａ（登録商標）はシリコンチップにおいて直接実行することができる。いくつかのＪａｖａ（登録商標）ハードウェアプロセッサは、いくつかの命令が１つの命令として組合わされ、実行されることを意味する、フォールディング機構を有する。しかしながら、ほとんどのＪａｖａ（登録商標）プロセッサはインタープリタとして動作し、そこでは各命令コードが読出され、次に命令を実行するために適切な処置が講じられる。   Java (registered trademark) developed by Sun Microsystems is an object-oriented programming language, has become the de facto standard in network programming, and is beginning to be used in the field of embedded systems. Java (registered trademark) bytecode is generally executed in a software layer called a Java (registered trademark) virtual machine, and its specifications are issued by Sun Microsystems. In order to execute Java® bytecode, an interpreter or “just-in-time” compiler, preferably in conjunction with some form of read-ahead technique for analyzing potential program flow bottlenecks Or a cross-compiler for a specific hardware platform may be used. Alternatively, Java can be run directly on a silicon chip. Some Java® hardware processors have a folding mechanism that means that several instructions are combined and executed as one instruction. However, most Java processors operate as interpreters, where each instruction code is read and then appropriate action is taken to execute the instruction.

Ｊａｖａ（登録商標）が組込システムにおいて実現される場合、ハードウェア手法が好ましい技術的解決法であり、近年、Ｊａｖａ（登録商標）仮想マシンのいくつかのハードウェアバージョンが組込プロセッサプラットフォーム用に開発されている。Ｊａｖａ（登
録商標）命令の直接の実行をサポートするこれらのプロセッサは、通常は３２ビットのスタックマシンとして設計されている。そのいくつかは、直接アドレス指定およびビット操作命令などの特徴を提供するために、Ｊａｖａ（登録商標）バイナリフォーマットへの拡張に依存する。他のものはＪａｖａ（登録商標）バイナリコードを直接実行はしないが極めて近いアーキテクチャ上の一致を有し、それによって仮想マシンの性能を向上させる。 If Java is implemented in an embedded system, the hardware approach is the preferred technical solution, and several hardware versions of Java virtual machines have recently been developed for embedded processor platforms. Has been developed. These processors that support the direct execution of Java instructions are usually designed as 32-bit stack machines. Some of them rely on extensions to the Java® binary format to provide features such as direct addressing and bit manipulation instructions. Others do not directly execute Java® binary code, but have very close architectural matches, thereby improving virtual machine performance.

ハードウェアにおいてＪａｖａ（登録商標）ＶＭの実現を試みるときの主な難問は、いくつかのＪａｖａ（登録商標）命令が高度な意味内容を有し、そのために不可分な命令として実行するのが非常に困難なことである。複雑なＪａｖａ（登録商標）命令をトラップし、ホストアーキテクチャにネイティブな命令を用いてソフトウェアルーチンとしてそれらを実行することが、可能な解決法である。しかし、これを行うためには、ネイティブな（ＲＩＳＣまたはＣＩＳＣ）命令を用いてＪａｖａ（登録商標）オペランドスタックにアクセスするための機構が必要である。   The main challenge when trying to implement a Java VM in hardware is that some Java instructions have a high semantic content, so it is very difficult to execute as an inseparable instruction. It is difficult. Trapping complex Java instructions and executing them as software routines using instructions native to the host architecture is a possible solution. However, in order to do this, a mechanism for accessing the Java operand stack using native (RISC or CISC) instructions is required.

２００１年４月２３日に出願された米国仮出願番号第６０／２８６，１９７号の優先権を伴って２００２年４月１日に出願された、本譲受人の先の米国特許出願番号第１０／１１４，６７８号であって２００４年１月２２日にＵＳ２００４／００１５６７８Ａｌとして発行された、「バイトコンパイルされたＪａｖａ（登録商標）コードを実行するためのマイクロプロセッサ（Microprocessor for executing byte compiled Java（登録商標）code）」と題された出願、および２００２年１０月３１日にＷＯ２００２／０８６６９９Ａ３として発行された対応する国際出願において、ＲＩＳＣマシンをＪａｖａ（登録商標）ＶＭと組合わせる概念が記載されている。当該以前に発行された出願において、ハードウェアで実現されるＲＩＳＣマイクロプロセッサとＪａｖａ（登録商標）ＶＭとが、ハードウェアがＲＩＳＣ状態またはＪａｖａ（登録商標）状態のいずれかにおいても動作することができるように、結合される。ＲＩＳＣマイクロプロセッサがＪａｖａ（登録商標）オペランドスタックにアクセスして複雑なＪａｖａ（登録商標）命令をＲＩＳＣソフトウェアルーチンとして実行するために、２つのビット「Ｘ」および「Ｙ」が状態レジスタに設定されて、対応するＸ引数またはＹ引数が、オペランドスタックポインタによって指定されたレジスタ番号と置換えられることを可能にする。   Assignee's earlier US Patent Application No. 10 filed April 1, 2002 with the priority of US Provisional Application No. 60 / 286,197, filed April 23, 2001. / 114,678, which was issued as US 2004/0015678 Al on January 22, 2004, "Microprocessor for executing byte compiled Java (registered) (Trademark) code) "and the corresponding international application published as WO2002 / 086699A3 on October 31, 2002, describes the concept of combining a RISC machine with a Java VM. . In the previously issued application, a RISC microprocessor implemented in hardware and a Java VM can operate in either the RISC state or the Java state. So that they are combined. Two bits "X" and "Y" are set in the status register for the RISC microprocessor to access the Java operand stack and execute complex Java instructions as RISC software routines. Allows the corresponding X or Y argument to be replaced with the register number specified by the operand stack pointer.

プロセッサのＲＩＳＣ（またはＣＩＳＣ）状態からＪａｖａ（登録商標）オペランドスタックへのアクセスを向上させるために、これらの結合マイクロプロセッサのための付加的な機構が求められる。   In order to improve access to the Java operand stack from the RISC (or CISC) state of the processor, additional mechanisms for these combined microprocessors are required.

発明の概要
この発明は、同じマイクロプロセッサコアにおいてＲＩＳＣ（またはＣＩＳＣ）マシンおよび（Ｊａｖａ（登録商標）ＶＭなどの）スタックマシンの両方を実現する。マイクロプロセッサはレジスタファイルを含む。先行するＲＩＳＣ（またはＣＩＳＣ）マシンと同じように、レジスタファイル上で演算する命令は、オペランドの出所および結果の行先であるレジスタ番号を特定する。スタックマシンは、Ｊａｖａ（登録商標）オペランドスタックを保持する同じレジスタファイルの部分（たとえば下半分）を用いる。Ｊａｖａ（登録商標）オペランドスタックポインタレジスタが与えられ、それはスタックトップを指定し、したがって、プロセッサがＪａｖａ（登録商標）状態である場合は常に、いずれのレジスタにおいて動作されるかを決定する。状態レジスタは、プロセッサがＪａｖａ（登録商標）状態にあるときを特定するビットを含んでいるだけでなく、プロセッサがＪａｖａ（登録商標）スタックにアクセスするためにＲＩＳＣ（またはＣＩＳＣ）状態である時に用いられるＪａｖａ（登録商標）レジスタ再マップビットを含む。ＲＩＳＣ（またはＣＩＳＣ）状態において、再マップビットは、設定されると、命令で特定されたレジスタ番号
が、Ｊａｖａ（登録商標）オペランドスタックのレジスタに対応する場合は、常に、そのレジスタ番号がスタックトップに関連するアクセスレジスタに再マップされるようにする。すなわち、アクセスされたレジスタ番号は、オペランドスタックポインタの最大値からオペランドスタックポインタ値を引いた値である。再マップビットがゼロにリセットされている場合、アクセスされたレジスタ番号は命令で特定されるものである。再マップビットはＪａｖａ（登録商標）状態では無視される。再マップビットは、ＲＩＳＣ（またはＣＩＳＣ）命令がＪａｖａ（登録商標）スタックのオペランドにアクセスすることを有効に可能にする。たとえば、いずれのレジスタが実際にスタックトップ値を保持しているかにかかわらず、スタックトップからオペランドを、かつスタックトップより下位の要素を得て、結果をスタックトップに置くことを可能にする。 SUMMARY OF THE INVENTION The present invention implements both a RISC (or CISC) machine and a stack machine (such as a Java VM) in the same microprocessor core. The microprocessor includes a register file. As with previous RISC (or CISC) machines, instructions that operate on a register file specify the source of the operand and the register number that is the destination of the result. The stack machine uses the same register file portion (eg, lower half) that holds the Java® operand stack. A Java (R) operand stack pointer register is provided, which specifies the stack top, and thus determines in which register whenever the processor is in the Java (R) state. The status register not only contains a bit that identifies when the processor is in Java state, but is also used when the processor is in RISC (or CISC) state to access the Java stack. Java (R) register remapping bits. In the RISC (or CISC) state, when the remapping bit is set, whenever the register number specified in the instruction corresponds to a register in the Java operand stack, that register number is always the stack top. To be remapped to the access register associated with That is, the accessed register number is a value obtained by subtracting the operand stack pointer value from the maximum value of the operand stack pointer. If the remapping bit is reset to zero, the accessed register number is the one specified in the instruction. The remapping bit is ignored in the Java state. The remapping bit effectively enables RISC (or CISC) instructions to access the operands of the Java stack. For example, regardless of which register actually holds the stack top value, it is possible to get operands from the stack top and elements below the stack top and place the result on the stack top.

発明の詳細な説明
この発明は、結合ＲＩＳＣ／Ｊａｖａ（登録商標）プロセッサアーキテクチャまたは結合ＣＩＳＣ／Ｊａｖａ（登録商標）プロセッサアーキテクチャのいずれかに、またはより一般にはスタックマシンとネイティブＲＩＳＣまたはネイティブＣＩＳＣプロセッサとの任意の結合に適合され得る。既に説明されたように、この発明は、プロセッサがそのスタックマシンまたはＪａｖａ（登録商標）状態であるときだけでなく、プロセッサがそのネイティブＲＩＳＣまたはネイティブＣＩＳＣ状態であるときも、オペランドスタックへのアクセスのための技術を特に含む。例示目的のために、説明の残りの部分は結合ＲＩＳＣ／Ｊａｖａ（登録商標）プロセッサアーキテクチャに注目し、そのコンテキストにおける創造性のある技術を示す。当業者は、この発明に説明されたＲＩＳＣ／Ｊａｖａ（登録商標）バージョンを他の適用可能な処理アーキテクチャでの使用に適応させる方法を容易に理解するだろう。 DETAILED DESCRIPTION OF THE INVENTION The present invention relates to either a combined RISC / Java® processor architecture or a combined CISC / Java® processor architecture, or more generally between a stack machine and a native RISC or native CISC processor. Any combination can be adapted. As already described, the present invention provides access to the operand stack not only when the processor is in its stack machine or Java state, but also when the processor is in its native RISC or native CISC state. In particular including technology for. For illustrative purposes, the remainder of the description focuses on the combined RISC / Java processor architecture and shows the creative techniques in that context. Those skilled in the art will readily understand how to adapt the RISC / Java® version described in this invention for use with other applicable processing architectures.

Ｊａｖａ（登録商標）ＶＭ命令セットは現在２０１の命令コードを含んでいる。命令セットの大部分はタイプ固有であり、したがって、同じ意味を有するが異なるオペランドタイプに適用されるＪａｖａ（登録商標）命令が多い。ＲＩＳＣプロセッサの命令セットは各アーキテクチャの特定の設計特微によって異なるが、典型的なＲＩＳＣ命令セットは、ＬＯＡＤ、ＳＴＯＲＥ、ＭＯＶＥ、ＡＤＤ、ＳＵＢＴＲＡＣＴ、ＭＵＬＴＩＰＬＹ、ＤＩＶＩＤＥ、ＮＥＧＡＴＥ、ＡＮＤ、ＯＲ、ＸＯＲ、ＣＯＭＰＡＲＥ、ＳＨＩＦＴ、ＲＯＴＡＴＥ、ＳＥＴ、ＣＬＥＡＲ、ＪＵＭＰおよびＲＥＴＵＲＮなどの命令を含み得る。典型的なＲＩＳＣ命令セットの大部分はＪａｖａ（登録商標）ＶＭ命令セットと重複する。たとえば、Ｊａｖａ（登録商標）およびＲＩＳＣ状態の両方において最も頻繁に実行される命令はロード／ストア命令であり、それは両方の状態下で同じ意味内容を有し、結合ＲＩＳＣ／Ｊａｖａ（登録商標）アーキテクチャにおいて同じハードウェア資源を共有することができる。同様に、基本的な算術演算および論理演算は同じ意味を共有し、共有される算術論理演算装置（ＡＬＵ）を同じ方法で利用する。しかしながら、いくらかの低レベルビット操作命令はＲＩＳＣ命令セットでのみ見つけることができ、Ｊａｖａ（登録商標）ＶＭでは見つからない。同様に、Ｊａｖａ（登録商標）は、典型的なＲＩＳＣ命令セットには見つからない高レベルのオブジェクト生成および操作命令を含む。   The Java (R) VM instruction set currently contains 201 instruction codes. Most of the instruction set is type specific, so there are many Java instructions that have the same meaning but apply to different operand types. Although the RISC processor instruction set varies depending on the specific design characteristics of each architecture, typical RISC instruction sets are LOAD, STORE, MOVE, ADD, SUBTRACT, MULTIPLY, DIVIDE, NEGATE, AND, OR, XOR, COMPARE, It may include instructions such as SHIFT, ROTATE, SET, CLEAR, JUMP, and RETURN. Most of the typical RISC instruction set overlaps the Java VM instruction set. For example, the most frequently executed instruction in both Java and RISC states is the load / store instruction, which has the same semantic content under both states, and is a combined RISC / Java architecture. Can share the same hardware resources. Similarly, basic arithmetic and logical operations share the same meaning and utilize shared arithmetic and logic units (ALUs) in the same way. However, some low-level bit manipulation instructions can only be found in the RISC instruction set and not in Java VM. Similarly, Java® includes high level object creation and manipulation instructions that are not found in the typical RISC instruction set.

Ｊａｖａ（登録商標）ＶＭ命令セットは、ハードウェアで実現するのが困難な高度な意味内容を有するいくつかの命令を含む。単一のクロックサイクルでそのような高レベルの命令を実行することは通常は実現可能ではなく、それらをいくつかのさほど複雑でない命令に分割する作業は資源の割振りとタイミングの制約との点で困難である。その代り、これらのＪａｖａ（登録商標）命令は、ハードウェアのオーバーヘッドを減じるために、結合ＲＩＳＣ／Ｊａｖａ（登録商標）プロセッサにおける小さなＲＩＳＣプログラムとしてトラップされて実行されてもよい。トラップされる命令は、典型的には、すべての実行された命令の１０％未満になる。個々のそのような命令のＲＩＳＣプログラムは、プロセッ
サにアクセス可能なプログラムメモリに格納され、プログラマによって必要に応じて変更されてもよい。これは、Ｊａｖａ（登録商標）命令セットのいかなる将来的な拡張に対しても十分な柔軟性を与える。しかし、高レベルなＪａｖａ（登録商標）命令をＲＩＳＣプログラムとして実行することは、結合プロセッサがＲＩＳＣ状態に切替わる場合は常に、それらの命令を実行するために結合プロセッサがなおＪａｖａ（登録商標）オペランドスタックにアクセスできることを必要とする。プロセッサがＪａｖａ（登録商標）状態に戻るときは、演算結果もスタックからアクセスされる必要がある。 The Java (R) VM instruction set includes a number of instructions with high semantic content that are difficult to implement in hardware. Executing such high-level instructions in a single clock cycle is usually not feasible, and the task of dividing them into several less complex instructions is in terms of resource allocation and timing constraints. Have difficulty. Instead, these Java instructions may be trapped and executed as a small RISC program in a combined RISC / Java processor to reduce hardware overhead. The instructions that are trapped will typically be less than 10% of all executed instructions. The RISC program for each such instruction is stored in a program memory accessible to the processor and may be modified as needed by the programmer. This provides sufficient flexibility for any future extension of the Java instruction set. However, executing a high level Java instruction as a RISC program means that whenever the combined processor switches to the RISC state, the combined processor still executes the Java operand to execute those instructions. Requires access to the stack. When the processor returns to the Java (registered trademark) state, the operation result also needs to be accessed from the stack.

図１を参照して、この発明を利用するために適合され得る典型的な結合ＲＩＳＣ／Ｊａｖａ（登録商標）マイクロプロセッサは、ＲＩＳＣプロセッサ、ＲＩＳＣプロセッサにおいてＪａｖａ（登録商標）命令の第１のセットを実行するためのＪａｖａ（登録商標）モジュール、ＲＩＳＣプロセッサにおいてＪａｖａ（登録商標）命令の第２のセットをマイクロコードとして実行するためのＲＩＳＣモジュール、および、両方のモジュールによって共有される、ＲＩＳＣプロセッサにおけるデータパスを含み得、データパスはレジスタファイルを含む。図１に見られるように、この発明によるマイクロプロセッサ１０は、Ｊａｖａ（登録商標）制御部１１およびＲＩＳＣ制御部１３の両方を含み、それは共通のデータパスを共有する。２つの制御部１１および１３は独立して動作するが、プロセッサを同時に動作することはない。プロセッサ１０は、他のＪａｖａ（登録商標）プロセッサのようにＪａｖａ（登録商標）バイナリフォーマットへの翻訳または拡張には依存しないが、２つの直交するプログラムモデルを提供する。プロセッサ１０は、データと命令との両方のための共通バスを共有する基本的なノイマンアーキテクチャ（von-Neumann Architecture）として構築することができ、または個別のデータおよび命令バスを備えたハーバードアーキテクチャ（Harvard Architecture）に容易に拡張することができる。プロセッサは高いクロック周波数および単一のサイクル実行を達成するためにパイプライン化することができる。   Referring to FIG. 1, a typical combined RISC / Java microprocessor that can be adapted to utilize the present invention is a RISC processor, a first set of Java instructions in a RISC processor. A Java module for execution, a RISC module for executing the second set of Java instructions as microcode in the RISC processor, and data in the RISC processor shared by both modules A path may include a data path, including a register file. As can be seen in FIG. 1, the microprocessor 10 according to the present invention includes both a Java controller 11 and a RISC controller 13, which share a common data path. The two controllers 11 and 13 operate independently, but do not operate the processors simultaneously. The processor 10 does not rely on translation or extension to the Java® binary format like other Java® processors, but provides two orthogonal program models. The processor 10 can be constructed as a basic von-Neumann Architecture that shares a common bus for both data and instructions, or a Harvard architecture with separate data and instruction buses (Harvard). Architecture) can be easily extended. The processor can be pipelined to achieve high clock frequencies and single cycle execution.

マイクロプロセッサは、データバス３０に接続されたレジスタファイル１５を含む。プログラムカウンタ１６、リンクレジスタ１７およびスタックポインタ１８は、任意の数の汎用レジスタ１９と共に、ファイル１５にマップされてもよい。レジスタファイル１５へのこのマッピングは、プログラムカウンタ１６、リンクレジスタ１７およびスタックポインタ１８が汎用レジスタ１９と同じ方法でアドレスされることを可能にし、その結果、通常の命令は、所望の場合は常にこれらのレジスタを用いることができる。スタックポインタ１８を通常のレジスタとしてアドレスできることにより、ローカル変数およびパラメータの割当ておよびアクセスが簡単になる。スタックポインタ１８は、いくつかの命令によって暗黙に用いられてもよい。プログラムカウンタ１６は、実行されている命令のアドレスを包含する。メモリ空間はバイト単位でアドレス指定される。Ｊａｖａ（登録商標）状態を除いて、命令のサイズは２バイトの倍数であり、プログラムカウンタの最下位ビットはゼロに固定されている。プログラムカウンタ１６がレジスタファイル１５にマップされるので、それはレジスタオペランドを用いるすべての命令（たとえばロード／ストア、算術および論理命令）において出所または行先オペランドとして用いることができる。プログラムカウンタ１６をその行先レジスタとして用いる命令はジャンプ命令と同じ方法で処理され、新しいプログラムカウンタ値によって特定されたアドレスにおいてパイプラインが消去され、実行が再開される。リンクレジスタ１７は、監視プログラム呼出しと同様に、サブルーチン呼び出し、割込みリクエスト、および例外処理の戻りアドレスを保持するために用いられる。リンクレジスタ位置は他のすべての場合に汎用レジスタとして用いることができる。割込みモードおよび例外モードについては、より低い割込みレイテンシでのより高い性能を可能にするために、個別のレジスタファイルが含まれてもよい。   The microprocessor includes a register file 15 connected to the data bus 30. Program counter 16, link register 17 and stack pointer 18 may be mapped to file 15 along with any number of general purpose registers 19. This mapping to the register file 15 allows the program counter 16, link register 17 and stack pointer 18 to be addressed in the same way as the general purpose register 19, so that normal instructions are always these if desired. Can be used. The ability to address the stack pointer 18 as a normal register simplifies the assignment and access of local variables and parameters. The stack pointer 18 may be used implicitly by some instructions. Program counter 16 contains the address of the instruction being executed. The memory space is addressed in bytes. Except for the Java (registered trademark) state, the instruction size is a multiple of 2 bytes, and the least significant bit of the program counter is fixed to zero. Since program counter 16 is mapped to register file 15, it can be used as a source or destination operand in all instructions that use register operands (eg, load / store, arithmetic and logical instructions). An instruction that uses the program counter 16 as its destination register is processed in the same way as a jump instruction, the pipeline is erased at the address specified by the new program counter value, and execution resumes. The link register 17 is used to hold a subroutine call, an interrupt request, and an exception processing return address in the same manner as the monitor program call. The link register location can be used as a general purpose register in all other cases. For interrupt and exception modes, separate register files may be included to allow higher performance with lower interrupt latencies.

状態レジスタ２１はレジスタファイル１５から区別され、その代わり、Ｊａｖａ（登録商標）オペランドスタックポインタ２２、Ｊａｖａ（登録商標）ローカル変数レジスタ２
３、およびＪａｖａ（登録商標）トラップ基底アドレスレジスタ２４とともにシステムレジスタ空間２０にマップされることができる。状態レジスタ２１は、通常の算術論理演算フラグ（たとえば、飽和、オーバーフロー、符号、ゼロおよびキャリーフラグ）、モードビット設定（たとえばアプリケーション、監視プログラム、割込みおよび例外モード）、デバッグ状態ビット、ならびに割込み、例外、およびデバッグマスキングビットを含んでいてもよい。さらに、この発明に特に関連して、状態レジスタ２１はＪａｖａ（登録商標）状態ビットおよびＪａｖａ（登録商標）レジスタ再マップビットを含む。プロセッサ１０は、状態レジスタ２１においてＪａｖａ（登録商標）状態ビットが設定されているときに限り、その場合は常に、Ｊａｖａ（登録商標）状態である。このビットはリセットにおいてクリアされ、Ｊａｖａ（登録商標）実行が完了したとき、または割込みおよび例外によって、または定義済み命令（たとえばＪＣＡＬＬまたはＲＥＴＪなど、前者はＪａｖａ（登録商標）状態を始めるために用いられ、後者は命令トラップ後にＪａｖａ（登録商標）状態に戻るために用いられる）によってのみ、変更されるべきである。このＪａｖａ（登録商標）状態ビットを手動で変更しようとするユーザによる試みは、結果として未定義動作を生じ得る。Ｊａｖａ（登録商標）レジスタ再マップビットが設定される場合は常に、スタックマシンにおけるのと同様に、レジスタファイル１５は変数にアクセスするために再マップされる。このビットはリセットにおいてクリアされる。このビットがＪａｖａ（登録商標）ＶＭの外部に書き出される場合、結果として未定義動作が生じ得る。この再マップビットの効果はより詳細に以下に記載される。システムレジスタ空間２０のＪａｖａ（登録商標）オペランドスタックポインタ２２は、現在のＪａｖａ（登録商標）オペランドスタックトップのレジスタファイル空間で位置を保持するために用いられる。Ｊａｖａ（登録商標）トラップ基底アドレスレジスタ２４は、トラップされたＪａｖａ（登録商標）命令のためのプログラムコードへの基底アドレスを包含している。Ｊａｖａ（登録商標）ローカル変数レジスタ２３は、一時的なＪａｖａ（登録商標）ローカル変数を格納する。追加的に、Ｊａｖａ（登録商標）トラップエントリポイントレジスタは、基底アドレスポインタから実現されていないＪａｖａ（登録商標）命令のエントリポイント用の例外ルーチンまでの、オフセットを包含してもよい。必要に応じて特定のハードウェアプロセッサ設計によって他のシステムレジスタが与えられてもよい。 The status register 21 is distinguished from the register file 15, and instead, a Java (registered trademark) operand stack pointer 22, a Java (registered trademark) local variable register 2.
3 and Java ™ trap base address register 24 and can be mapped to system register space 20. The status register 21 contains normal arithmetic and logic flags (eg, saturation, overflow, sign, zero and carry flags), mode bit settings (eg, application, supervisor, interrupt and exception modes), debug status bits, and interrupts, exceptions. , And debug masking bits. Further specifically related to the present invention, status register 21 includes a Java® status bit and a Java® register remapping bit. The processor 10 is always in the Java (registered trademark) state only when the Java (registered trademark) status bit is set in the status register 21. This bit is cleared at reset and when the Java execution is complete, or by interrupts and exceptions, or the predefined instruction (eg, JCALL or RETJ, the former is used to enter the Java state , The latter is used to return to the Java state after an instruction trap). Attempts by the user to manually change this Java status bit can result in undefined behavior. Whenever the Java register remapping bit is set, the register file 15 is remapped to access the variable, as in the stack machine. This bit is cleared at reset. If this bit is written outside the Java VM, an undefined operation can result. The effect of this remapping bit is described in more detail below. The Java (R) operand stack pointer 22 in the system register space 20 is used to hold a position in the register file space at the current Java (R) operand stack top. The Java® trap base address register 24 contains the base address to the program code for the trapped Java® instruction. The Java (registered trademark) local variable register 23 stores a temporary Java (registered trademark) local variable. Additionally, the Java trap entry point register may contain an offset from the base address pointer to the exception routine for the Java command entry point that is not implemented. Other system registers may be provided by specific hardware processor designs as needed.

ＲＩＳＣおよびＪａｖａ（登録商標）状態の両方で用いられる算術論理演算装置（ＡＬＵ）２５はレジスタファイル１５に接続され、ＡＬＵの出力はデータバス３０に与えられる。典型的なＡＬＵは３２ビットの加算器、３２ビットのバレルシフタ、およびハードウェア乗算を含むことができる。算術論理演算は単一クロックサイクルにおいて実行する。３２ビットワードサイズのデータタイプに加えて、プロセッサは典型的には、コードサイズまたは性能における制約なく、ハーフワードおよびバイトのデータタイプをサポートする。メモリのロードおよびストア動作は、典型的には、バイト、ハーフワード、ワード、ならびに、バイトおよびハーフワードデータの自動的な符号拡張またはゼロ拡張を備えたダブルワードのデータを与える。   An arithmetic logic unit (ALU) 25 used in both the RISC and Java (registered trademark) state is connected to the register file 15, and the output of the ALU is given to the data bus 30. A typical ALU can include a 32-bit adder, a 32-bit barrel shifter, and hardware multiplication. Arithmetic logic operations are performed in a single clock cycle. In addition to 32-bit word size data types, processors typically support halfword and byte data types without any restrictions in code size or performance. Memory load and store operations typically provide byte, halfword, word, and doubleword data with automatic sign extension or zero extension of byte and halfword data.

プログラムカウンタ１６および関連するレジスタファイルの出力は、アドレスマルチプレクサ３３に至る加算器３６を通って処理される。アドレスマルチプレクサ３３もアドレスバス４０に接続される。命令フェッチデコーダ３５はデータバス３０から信号を受け取り、スタック制御部３７に出力を与える。この発明と共に、プロセッサアーキテクチャのこの、または他の典型的な構成が用いられ得る。   The output of the program counter 16 and associated register file is processed through an adder 36 that leads to an address multiplexer 33. The address multiplexer 33 is also connected to the address bus 40. The instruction fetch decoder 35 receives a signal from the data bus 30 and provides an output to the stack control unit 37. With this invention, this or other typical configurations of processor architectures may be used.

ＲＩＳＣの大部分とＪａｖａ（登録商標）ＶＭ命令セットとが重複するので、結合ＲＩＳＣ／Ｊａｖａ（登録商標）プロセッサはハードウェア資源を共有するが、個別のＪａｖａ（登録商標）命令デコーダと、プロセッサがそのＪａｖａ（登録商標）状態にあるときに実行を引き継ぐ制御モジュール１１とを備える。プロセッサは、その状態レジスタ２１を通じて実行状態の経過を追い、実行状態を継目なく変更することができる。プロセッサ
をその一部に含むより大きなランタイムシステムでは、典型的には異なるプロセスの経過を追い、負荷配分するオペレーティングシステムがある。Ｊａｖａ（登録商標）プログラムは典型的にはそのようなプロセスのいくつかのうちの１つである。ネイティブプロセス（ＲＩＳＣまたはＣＩＳＣ）へのコンテキスト切替と比較して、Ｊａｖａ（登録商標）プロセスへのコンテキスト切替に関連する余分のオーバーヘッドは、たとえあったとしても僅かである。さらに、プロセッサが命令デコーダを切り替える（ＲＩＳＣ制御モジュール１３からＪａｖａ（登録商標）制御モジュール１１へ、またはその逆に）とき、それはシステムによって設定されたセキュリティレベルに影響しない。さらに、Ｊａｖａ（登録商標）プログラムは、原則的には、プロセッサのモード設定と干渉することなく異なる割込みレベルから実行することができるが、対応するＲＩＳＣ割込みルーチンに比較してレイテンシが増大しているので、一般に割込みルーチンがＪａｖａ（登録商標）で書かれることは推奨されない。 Because the majority of RISC overlaps with the Java VM instruction set, the combined RISC / Java processor shares hardware resources, but separate Java instruction decoders and processors And a control module 11 that takes over execution when in the Java (registered trademark) state. The processor keeps track of the execution state through the state register 21 and can change the execution state seamlessly. In larger runtime systems that include processors as part of them, there are typically operating systems that keep track of the different processes and distribute the load. A Java program is typically one of several such processes. Compared to context switching to a native process (RISC or CISC), there is little, if any, overhead associated with context switching to a Java process. Furthermore, when the processor switches instruction decoders (from RISC control module 13 to Java control module 11 or vice versa), it does not affect the security level set by the system. Furthermore, Java® programs can in principle be executed from different interrupt levels without interfering with the processor mode setting, but with increased latency compared to the corresponding RISC interrupt routine. Therefore, it is generally not recommended that the interrupt routine be written in Java (registered trademark).

図２を参照して、マイクロプロセッサは、初期化コードを実行するためにＲＩＳＣ状態で起動する（５１）。初期化５２の後に、マイクロプロセッサは正常なＲＩＳＣプロセッサとしてアプリケーションを実行することができ、またはＪａｖａ（登録商標）状態に切替わって（５３）Ｊａｖａ（登録商標）プログラムの実行を開始してもよい（５４）。Ｊａｖａ（登録商標）プログラムを呼び出すために、他のアプリケーションと同じくＪａｖａ（登録商標）ＶＭが呼び出される。特に、Ｊａｖａ（登録商標）ＶＭは初期化ルーチンを実行し、次に、クラスを解析してＪａｖａ（登録商標）プログラムの実行を開始するのに必要なレジスタを初期化するクラスローダが後続する。クラスローダにおける最後の命令は、プロセッサをＪａｖａ（登録商標）状態に設定するｊｃａｌｌ命令である。これは、命令デコーダがここではネイティブＲＩＳＣ命令コードの代わりにＪａｖａ（登録商標）命令コードをデコードすることを意味する。マイクロプロセッサは、以下の事象のうち１つが生じるまでＪａｖａ（登録商標）状態で動作し続ける：ＲＩＳＣモードに切替わって戻るための指定Ｊａｖａ（登録商標）命令コード（５８）、割込みリクエスト（５９）、または実現されていないＪａｖａ（登録商標）命令（６０）である。これらの事象のうちいずれかが生じれば、プロセッサは定義済みのアドレスにジャンプし、ＲＩＳＣモードに切替わって（５５）このやり方で事象を処理する。ＲＩＳＣルーチンを終了する際（５６）、プロセッサはＲＥＴＪ命令を用いてＪａｖａ（登録商標）状態に戻り（５７）、それが終わった時点においてＪａｖａ（登録商標）コードを実行し続ける。   Referring to FIG. 2, the microprocessor starts in a RISC state to execute initialization code (51). After initialization 52, the microprocessor can execute the application as a normal RISC processor, or it can switch to the Java state and start executing the Java program (53). (54). In order to call the Java (registered trademark) program, the Java (registered trademark) VM is called in the same manner as other applications. In particular, the Java® VM executes an initialization routine, followed by a class loader that parses the class and initializes the registers necessary to begin execution of the Java® program. The last instruction in the class loader is a jcall instruction that sets the processor to the Java (registered trademark) state. This means that the instruction decoder now decodes the Java instruction code instead of the native RISC instruction code. The microprocessor continues to operate in Java state until one of the following events occurs: Designated Java instruction code (58) to switch back to RISC mode, interrupt request (59) Or Java instruction (60) not implemented. If any of these events occur, the processor jumps to a predefined address and switches to RISC mode (55) to process the event in this manner. Upon exiting the RISC routine (56), the processor uses the RETJ instruction to return to the Java state (57), at which point it continues to execute the Java code.

このように、プロセッサはＪａｖａ（登録商標）状態でプログラムのＪａｖａ（登録商標）部分を実行することができる。このような部分は、企業のソフトウェアライブラリにおいて既に実現されているネットワーク能力またはアルゴリズムであってもよく、再使用のためのレガシーソフトウェア（legacy software）のモジュールを構成することができる。プロセッサのＲＩＳＣ状態は、複雑なＪａｖａ（登録商標）命令をＲＩＳＣマイクロコードとして実行することによって（６０）Ｊａｖａ（登録商標）コードの実行を補助する。それはさらに、たとえばセンサおよびアクチュエータなどの高度に専門化された周辺機器を制御するために用いることができる柔軟なハードウェアインタフェースをも与える。   In this way, the processor can execute the Java (registered trademark) part of the program in the Java (registered trademark) state. Such a portion may be a network capability or algorithm already implemented in the enterprise software library, and may constitute a legacy software module for reuse. The RISC state of the processor assists in the execution of (60) Java code by executing complex Java instructions as RISC microcode. It also provides a flexible hardware interface that can be used to control highly specialized peripherals such as sensors and actuators.

Ｊａｖａ（登録商標）ＶＭ仕様と互換性を有するために、すべてのＪａｖａ（登録商標）命令を実現する必要がある。しかしながら、中小のアプリケーションをターゲットにした組込プロセッサにおいては、Ｊａｖａ（登録商標）仮想マシンにサポートされる数の書式のいくつかは限度を越えている。たとえば、このセグメントでは浮動小数点ユニットを提供するプロセッサはほとんどない。Ｊａｖａ（登録商標）のより複雑な命令のいくつかはトラップされてマイクロコードとして実行されなければならない。「複雑な」というのは、単一のＪａｖａ（登録商標）命令が、実行のために複数のマシンクロックサイクルを必要とすることを意味する。Ｊａｖａ（登録商標）プログラムの実行中、プロセッサがハ
ードウェアでサポートされないバイトコードに遭遇する場合は常に、命令デコーダは自動的にこれらのバイトコードを認識し、プロセッサをそのＲＩＳＣ状態に切り替えて、同時に、定義済みのエントリポイント（Ｊａｖａ（登録商標）トラップ基底アドレスシステムレジスタに格納されたアドレスに相対して定義され、オフセットは特定のトラップされた命令に依存して基底アドレスに適用される）にジャンプする。次いで、それはトラップされたバイトコードの意味を実施するＲＩＳＣソフトウェアルーチンを実行する。終了すると、ルーチンはＪａｖａ（登録商標）状態に戻る命令（ＲＥＴＪ）で終わる。 In order to be compatible with the Java (registered trademark) VM specification, it is necessary to implement all Java (registered trademark) instructions. However, in embedded processors targeting small and medium applications, some of the number formats supported by the Java virtual machine are beyond limits. For example, few processors provide floating point units in this segment. Some of Java's more complex instructions must be trapped and executed as microcode. “Complex” means that a single Java instruction requires multiple machine clock cycles for execution. During the execution of a Java program, whenever the processor encounters bytecodes that are not supported in hardware, the instruction decoder automatically recognizes these bytecodes and switches the processor to its RISC state at the same time. Jump to a predefined entry point (defined relative to the address stored in the Java trap base address system register, offset applied to the base address depending on the particular trapped instruction) To do. It then executes a RISC software routine that implements the meaning of the trapped bytecode. When finished, the routine ends with an instruction (RETJ) to return to the Java state.

いずれのＪａｖａ（登録商標）命令をトラップするか、またいずれをハードウェアで直接実現するかは、通常、設計者によって決定される実現形態固有の問題である。典型的には、Ｊａｖａ（登録商標）オブジェクトを生成したり操作したりする命令がトラップされる。他のトラップされる命令は、長い（６４ビットまたはマルチワード）データタイプで動作するもの、浮動およびダブルのタイプのもの、および設計されたアーキテクチャと互換性がないものを含むことができる。   Which Java (registered trademark) instructions are trapped and which are directly implemented in hardware are usually implementation-specific issues determined by the designer. Typically, instructions for creating and manipulating Java objects are trapped. Other trapped instructions can include those that operate on long (64-bit or multiword) data types, those that are floating and double types, and those that are not compatible with the designed architecture.

この発明は、本願明細書に記載されたＲＩＳＣアーキテクチャに加えて他の型のＲＩＳＣアーキテクチャと共に用いることもできるので、いずれのＲＩＳＣ命令セットを用いるかは選ばれるＲＩＳＣモデルに依存する。（上述のように、この発明はまた、ＣＩＳＣアーキテクチャおよび命令セットとともに使用するようにも適合可能である。）
図３を参照して、プロセッサのレジスタファイルは、そのＪａｖａ（登録商標）状態においてプッシュポップスタックの機能を有するが、ネイティブＲＩＳＣ状態においては従来のロード／ストアレジスタファイルとして機能する。これはさらに、２つの仮想プロセッサが通信することを可能にするモジュールでもあり、Ｊａｖａ（登録商標）スタックにおいて与えられた値はＲＩＳＣ状態のプロセッサによってアクセスされ得る。図３は、ＲＩＳＣモードおよびＪａｖａ（登録商標）モードから見られるようにレジスタファイルの半分を示す。レジスタ８０、８１、…、８２は、Ｊａｖａ（登録商標）制御部６１および回路７１のＲＩＳＣ部分の両方から見られる。 Since the present invention can be used with other types of RISC architectures in addition to the RISC architecture described herein, which RISC instruction set is used depends on the RISC model chosen. (As mentioned above, the present invention is also adaptable for use with CISC architectures and instruction sets.)
Referring to FIG. 3, the processor register file has a push-pop stack function in its Java (registered trademark) state, but functions as a conventional load / store register file in the native RISC state. This is also a module that allows two virtual processors to communicate, and the values given in the Java stack can be accessed by processors in the RISC state. FIG. 3 shows half of the register file as seen from the RISC mode and Java mode. Registers 80, 81,..., 82 are seen from both the Java (registered trademark) control unit 61 and the RISC portion of the circuit 71.

レジスタファイルアーキテクチャのＲＩＳＣ図７１は、ロード／ストアレジスタ０からＭまでのセットとしてレジスタ要素８０、８１、…、８２を見、ＲＩＳＣアーキテクチャは、特定のレジスタを出所または行先として指定する対応するロード／ストア命令７２、７３、…、７４を用いてこれらのレジスタをデータメモリとインターフェイスする。プログラムカウンタ、リンクレジスタおよびスタックポインタが汎用レジスタと一緒にレジスタファイルに含まれることを思い出されたい。直交性（orthogonality）を保つために、これらの特別なレジスタは他の任意のレジスタと同じくアクセス可能である。   RISC FIG. 71 of register file architecture sees register elements 80, 81,..., 82 as a set of load / store registers 0 through M, and the RISC architecture specifies the corresponding load / store specifying a particular register as a source or destination. These registers are interfaced with the data memory using store instructions 72, 73,. Recall that the program counter, link register, and stack pointer are included in the register file along with general purpose registers. In order to preserve orthogonality, these special registers are accessible like any other register.

Ｊａｖａ（登録商標）制御部６１は、典型的には約（Ｍ＋ｌ）／２のレジスタ要素を備えた同じレジスタファイルをプッシュポップスタックとして見る。データはレジスタスタックにプッシュされ（６２）、レジスタスタックからＪａｖａ（登録商標）制御部へポップする（６３）。とりわけ、プログラムカウンタ、スタック制御レジスタおよび一時的スクラッチパッドレジスタ用に、残りのレジスタが用いられてもよい。スタックは循環スタックとして実現され、必要とされるスタックのサイズは比較的小さい。スタックのサイズはスケーラブルであり、スタック要素の数は実現形態固有の問題として残される。スタックオーバーフロー／アンダフローは、オーバーフロー／アンダフロー機構を通してメモリ８３内にコピーすることができる。あり得るスタックオーバーフロー／アンダフロー機構も場合に応じた態様で開発することができる。   The Java (registered trademark) control unit 61 typically sees the same register file with about (M + 1) / 2 register elements as a push-pop stack. The data is pushed onto the register stack (62) and popped from the register stack to the Java control unit (63). In particular, the remaining registers may be used for the program counter, stack control register, and temporary scratch pad register. The stack is implemented as a circular stack, and the required stack size is relatively small. The stack size is scalable, and the number of stack elements remains an implementation specific issue. Stack overflow / underflow can be copied into memory 83 through an overflow / underflow mechanism. Possible stack overflow / underflow mechanisms can also be developed in a case-by-case manner.

図４は、マイクロプロセッサを１つの状態から別の状態へ変換するための機構の１つの可能な実現形態を示す。Ｊａｖａ（登録商標）制御モジュール１２０およびＲＩＳＣ制御モジュール１２２は、マルチプレクサ１２４を通してプロセッサの共用データパスに至る
制御線１３０に接続される。状態レジスタ１２６は、Ｊａｖａ（登録商標）制御モジュール１２０およびＲＩＳＣ制御モジュール１２２に与えられるＪａｖａ（登録商標）状態ビット１２８を包含し、かつこれらの制御部のいずれが動作中かを決定する。Ｊａｖａ（登録商標）状態ビット１２８は、マルチプレクサ１２４による選択制御としても機能する。制御は両方の制御モジュールにおいて定義済みの状態で変換される。したがって制御は同期して変換され、両方の機械が定義された同じ状態になる。 FIG. 4 shows one possible implementation of a mechanism for converting a microprocessor from one state to another. The Java® control module 120 and the RISC control module 122 are connected to a control line 130 that leads through the multiplexer 124 to the shared data path of the processor. The status register 126 includes a Java® status bit 128 that is provided to the Java® control module 120 and the RISC control module 122 and determines which of these controls is in operation. The Java (registered trademark) status bit 128 also functions as a selection control by the multiplexer 124. Control is converted in a predefined state in both control modules. Thus, control is converted synchronously and both machines are in the same defined state.

Ｊａｖａ（登録商標）命令トラップは典型的な割込み機構のステップに類似のステップを含む。実現されない命令が発生すると、ＪＡＶＡ（登録商標）制御モジュールはこれを検出し、戻りアドレスがスタックトップに格納される。次いで、プロセッサはＲＩＳＣモードに切替わり、メモリの定義済みの位置からジャンプアドレスをフェッチする。次いで、ＲＩＳＣモジュールは、最後のステップでフェッチされたアドレスにおいて実行を継続する。最初の第１のジャンプアドレスだけが設計中に事前定義されるので、トラップ機構が割込み機構に類似していることにより最大の柔軟度を達成する。これはソフトウェアリンカが、プログラム内に実際に存在するＪａｖａ（登録商標）命令コード用のＲＩＳＣルーチンのみをリンクすることによりメモリ使用量を最適に計画することを可能にし、したがって貴重なメモリ空間を節約する。ＲＩＳＣルーチンは、スタックトップからプログラムカウンタをポップしてプログラムカウンタレジスタ内に保存することにより終了すべきである。これは、Ｊａｖａ（登録商標）プログラムが正しい場所で継続することを確実にする。さらに、マイクロプロセッサはスタックオーバーフロー／アンダフロー処理機構を有する。Ｊａｖａ（登録商標）プッシュポップスタックにおけるこの機構は、命令トラップ用の既存の論理を再使用することにより実現することができる。オーバーフローが発生すると、プロセッサはオーバーフローフラグをトラップして定義済みアドレスにジャンプし、そこでオーバーフロー／アンダフロー条件を処理するソフトウェア手順へのジャンプベクタを見つける。   Java instruction traps contain steps similar to those of a typical interrupt mechanism. When an unrealized instruction occurs, the JAVA (registered trademark) control module detects this, and the return address is stored at the top of the stack. The processor then switches to RISC mode and fetches the jump address from a predefined location in memory. The RISC module then continues execution at the address fetched in the last step. Since only the first first jump address is predefined during the design, the trap mechanism is similar to the interrupt mechanism to achieve maximum flexibility. This allows the software linker to optimally plan memory usage by linking only RISC routines for Java instruction code that actually exist in the program, thus saving valuable memory space. To do. The RISC routine should end by popping the program counter from the top of the stack and storing it in the program counter register. This ensures that the Java program continues in the right place. Further, the microprocessor has a stack overflow / underflow processing mechanism. This mechanism in the Java push pop stack can be implemented by reusing existing logic for instruction traps. When an overflow occurs, the processor traps the overflow flag and jumps to a predefined address where it finds a jump vector to the software procedure that handles the overflow / underflow condition.

図５を参照して、Ｊａｖａ（登録商標）状態とＲＩＳＣ状態とではレジスタファイルの機能が異なる。既に上述されたように、両方の状態において、プログラムカウンタ（ＰＣ）、リンクレジスタ（ＬＲ）、およびシステムまたはアプリケーションスタックポインタ（ＳＰ）に対して３つのレジスタ（ここではＲ１５−Ｒ１３）が専ら与えられる。ＲＩＳＣ状態においては、レジスタファイル９０の他のレジスタ（ここではＲ１２−Ｒ０）は、アドレス指定オペランドなどの正常なＲＩＳＣ動作に利用可能である。Ｊａｖａ（登録商標）状態では、Ｊａｖａ（登録商標）ＶＭはゼロオペランドスタックマシンとして実行するので、レジスタファイル機能はプッシュポップスタックを容易にするために変更され、そこでオペランドスタックの現在のトップはＴｏＳからＴｏＳ−７（ここではレジスタＲ７−Ｒ０を使用）のいずれかであり得る。さらに、他のレジスタ（Ｒ９およびＲ８など）は、Ｊａｖａ（登録商標）ローカル変数０（システムレジスタ空間１００における７つのＪａｖａ（登録商標）ローカル変数レジスタ１０４のうち１つ）を指定する現在のフレームのためのアドレスを包含するフレームレジスタとして、かつ現在のＪａｖａ（登録商標）クラスの定数プールへのアドレスを包含する定数プールレジスタとして、Ｊａｖａ（登録商標）において用いられてもよい。Ｊａｖａ（登録商標）ローカル変数レジスタに加えて、システムレジスタ空間１００は、現在のオペランドスタックトップ（ここでもＴｏＳからＴｏＳ−７までのいずれか）を指定するオペランドスタックポインタ１０２を含む。   Referring to FIG. 5, the function of the register file is different between the Java (registered trademark) state and the RISC state. As already mentioned above, in both states, three registers (here R15-R13) are given exclusively to the program counter (PC), link register (LR), and system or application stack pointer (SP). . In the RISC state, the other registers in register file 90 (here R12-R0) are available for normal RISC operations such as addressing operands. In the Java state, since the Java VM runs as a zero operand stack machine, the register file function has been changed to facilitate push-pop stacks, where the current top of the operand stack is from ToS. It can be any of ToS-7 (here, registers R7-R0 are used). In addition, other registers (such as R9 and R8) have a current local frame 0 that specifies Java local variable 0 (one of the seven Java local variable registers 104 in the system register space 100). It may be used in Java as a frame register that contains the address for and as a constant pool register that contains the address to the current Java class constant pool. In addition to the Java local variable register, the system register space 100 includes an operand stack pointer 102 that points to the current operand stack top (again, any of ToS to ToS-7).

Ｊａｖａ（登録商標）オペランドスタック（ＴｏＳからＴｏＳ−７）は、Ｊａｖａ（登録商標）命令によって動作される値および動作の結果を保持する。オペランドスタックは現在の方法フレームの一部であり、オペランドスタックの一部は動作を促進するためにレジスタファイルに保持される。ここに示されるように、レジスタファイルは典型的にはオペランドスタックの最大８つの要素を保持し、スタックの残りはＪａｖａ（登録商標）ＶＭフレームの一部としてメモリに格納されている。（フレームは、Ｊａｖａ（登録商標）
メソッドの実行をサポートするためのすべての変数および基準値を保持するランタイムデータ構造であり、メソッドへの入力引数と同様に、呼び出されたメソッドから出力される引数も包含することができる。メソッドが呼び出されるとフレームが割り付けられ、プログラムがメソッドから戻ると破棄される。例示的なフレームは、オペランドスタック、ローカル変数、次のフレームが置かれ得る自由なメモリ空間へのポインタ、メソッドへの戻りアドレス、前のメソッドのためのフレームポインタ、ならびに前のメソッドのための一定のプールポインタおよびスタックポインタを含み得る。システムレジスタ１００は、２つの機能を有するＪａｖａ（登録商標）オペランドスタックポインタ１０２を含む。それはオペランドスタック上の要素の数を示し、かつ現在のスタックトップを保持するレジスタを（たとえばビット［２：０］で）指定する。オペランドスタックポインタが０値に初期化され、これはオペランドスタックが空であることを意味する。オペランドスタックがオーバーフローするかアンダフローした場合は例外が生成され、例外ルーチンは、オペランドスタックのコンテンツをレジスタファイルからメモリに格納された現在のメソッドフレームにコピーすることを担う（たとえば、最大８つの要素のスタックを包含するレジスタファイルにおいて、第９の要素がスタックにプッシュされる場合は常にオーバーフロー条件が生じる。空のスタックからアクセスが試みられる場合はアンダフロー条件が生じる）。 The Java (R) operand stack (ToS to ToS-7) holds the values and the results of operations performed by Java (R) instructions. The operand stack is part of the current method frame, and part of the operand stack is kept in a register file to facilitate operation. As shown here, a register file typically holds up to eight elements of an operand stack, with the remainder of the stack being stored in memory as part of a Java VM frame. (The frame is Java (registered trademark).
A runtime data structure that holds all variables and reference values to support method execution, and can include arguments output from the invoked method as well as input arguments to the method. A frame is allocated when the method is called, and discarded when the program returns. An exemplary frame includes an operand stack, local variables, a pointer to free memory space where the next frame can be placed, a return address to the method, a frame pointer for the previous method, and a constant for the previous method Pool pointers and stack pointers. The system register 100 includes a Java (registered trademark) operand stack pointer 102 having two functions. It indicates the number of elements on the operand stack and specifies the register holding the current stack top (eg, with bits [2: 0]). The operand stack pointer is initialized to a zero value, which means that the operand stack is empty. An exception is generated if the operand stack overflows or underflows, and the exception routine is responsible for copying the contents of the operand stack from the register file to the current method frame stored in memory (eg, up to 8 elements In a register file that contains a stack of any number of times, an overflow condition occurs whenever the ninth element is pushed onto the stack, and an underflow condition occurs when an access is attempted from an empty stack).

トラップルーチンは、プロセッサのＲＩＳＣ状態においてＪａｖａ（登録商標）オペランドスタックにアクセスする必要がある。Ｊａｖａ（登録商標）オペランドスタックポインタ１０２を読出し、それを正しいレジスタに翻訳しなければならないという厄介なプロセスを回避するために、プロセッサのＪａｖａ（登録商標）制御部は、制御をＲＩＳＣユニットに転送することに先立って、再マップされたレジスタファイル９０ａを生成するレジスタ再マップ動作を実行し、それはスタックトップ（ＴｏＳ）が常にレジスタＲ７にあり、ＴｏＳ−１が常にレジスタＲ６にある、などと続くことを確実にする。状態レジスタ１０１では再マップビットＲＭが与えられる。プロセッサがスタックマシンとして動く場合、すなわちＪａｖａ（登録商標）状態では常にこの再マップビットＲＭは無視される。しかしながら、プロセッサのネイティブＲＩＳＣ状態では、再マップビットＲＭは下記の意味を有する：
if RM is 0, then
アクセスされるレジスタ番号＝特定されるレジスタ番号
（すなわち再マップは生じない）；
if RM is 1, then
アクセスされるレジスタ番号＝オペランドスタックポインタの最大値−オペランドスタックポインタ値。 The trap routine needs to access the Java (R) operand stack in the processor's RISC state. To avoid the cumbersome process of having to read the Java operand stack pointer 102 and translate it into the correct register, the processor's Java controller transfers control to the RISC unit. Prior to that, perform a register remapping operation to generate a remapped register file 90a, which continues with the stack top (ToS) always in register R7, ToS-1 always in register R6, and so on. Make sure. In the status register 101, a remapping bit RM is given. When the processor operates as a stack machine, that is, in the Java (registered trademark) state, this remapping bit RM is always ignored. However, in the processor's native RISC state, the remapping bit RM has the following meaning:
if RM is 0, then
Register number accessed = Register number specified (ie no remapping occurs);
if RM is 1, then
Register number to be accessed = maximum value of operand stack pointer−operand stack pointer value.

たとえば、ＴｏＳからＴｏＳ−７までの８つのレジスタスタックでは、オペランドスタックポインタの最大値は７である。再マップビットＲＭが「１」に設定されると、Ｒ７からＲ０へのレジスタ番号は、ＴｏＳからＴｏＳ−７までのスタック要素をそれぞれ保持するレジスタにアクセスする。add R7, R6というＲＩＳＣ命令は、ＴｏＳおよびＴｏＳ−１を有効に加算する。オペランドスタックポインタがレジスタＲ３を指定した場合、ＴｏＳおよびＴｏＳ−１が格納される実際のレジスタはそれぞれＲ３およびＲ２であり、加算演算器はこれら２つの物理レジスタを加算演算に用いる。   For example, in the eight register stacks from ToS to ToS-7, the maximum value of the operand stack pointer is 7. When the remapping bit RM is set to “1”, the register number from R7 to R0 accesses the registers respectively holding the stack elements from ToS to ToS-7. The RISC instructions add R7 and R6 effectively add ToS and ToS-1. When the operand stack pointer specifies the register R3, the actual registers in which ToS and ToS-1 are stored are R3 and R2, respectively, and the adder uses these two physical registers for the addition operation.

図７は、再マップ装置１７３がＲＩＳＣプロセッサの制御部１７１の外部に取付けられる典型的な配列を示す。各再マップ装置１７３を形成する論理回路は、レジスタファイル１７５にある読書きポートの数と同じ回数反復実行される。各再マップ装置１７３は、制御入力ＲＭ（ＲＭ＝１であれば再マップ動作を可能にし、ＲＭ＝０であれば再マップなく受取られるレジスタアドレスをパスする）および、スタックトップの位置を表示するＪａｖａ（登録商標）オペランドスタックポインタ（図５の１０２）からのＪＯＳＰを有する
。（ＪＯＳＰは、一般に再マップ可能なレジスタ位置の数に対応するマルチビット信号である。）各再マップ装置１７３はレジスタアドレス入力１７３Iおよびレジスタアドレス出力１７３Ｏを有する。レジスタアドレス入力１７３Iはプロセッサ制御論理１７１から個別のレジスタアドレスを受取る。次いで、レジスタアドレス出力１７３Ｏは、対応する物理レジスタアドレスをレジスタファイル１７１のポートに出力する。図５において与えられた例では、Ｊａｖａ（登録商標）オペランドスタックポインタ１０２はスタックトップ値３を与え（ＪＯＳＰ＝３）、次いでＲＭ＝１の場合は常に、レジスタアドレス入力１７３Iがそれぞれ７および６であれば（たとえばadd R7, R6という命令について）、レジスタアドレス出力１７３Ｏは、レジスタファイル１７５のレジスタＲ３およびＲ２にアクセスするために、実際の物理的位置として再マップされた値３および２を与える。 FIG. 7 shows a typical arrangement in which the remapping device 173 is mounted outside the RISC processor controller 171. The logic circuit forming each remapping unit 173 is repeatedly executed as many times as the number of read / write ports in the register file 175. Each remapping device 173 displays a control input RM (if RM = 1, allows remapping operation, if RM = 0, passes register address received without remapping) and stack top position It has a josp from the Java (registered trademark) operand stack pointer (102 in FIG. 5). (JOSP is generally a multi-bit signal corresponding to the number of register locations that can be remapped.) Each remapping device 173 has a register address input 173 I and a register address output 173 O. Register address input 173 I receives an individual register address from processor control logic 171. Next, the register address output 173 O outputs the corresponding physical register address to the port of the register file 171. In the example given in FIG. 5, Java operand stack pointer 102 gives stack top value 3 (JOSP = 3), then whenever RM = 1, register address input 173 I is 7 and 6, respectively. If so (for example, for the instructions add R7, R6), register address output 173 O uses values 3 and 2 remapped as actual physical locations to access registers R3 and R2 of register file 175. give.

オペランドスタックに対して新しい値をプッシュするとき、スタックの一貫性を確実にするために、特別な、インクリメントＪａｖａ（登録商標）オペランドスタックポインタ命令「ｉｎｃｊｏｓｐ」を用いなければならない。この命令は、オペランドスタックポインタ１０２を特定された量Ｎずつインクリメントし、それにより、すべてのオペランドスタック要素をＮ要素分だけ下にプッシュする。これは、スタックトップのＮ要素を自在にする。スタックの上に進む値は、その後Ｒ７に移動させることができる。オペランドスタックポインタをディクリメントすることにより、スタックから要素をポップするためにｉｎｃｊｏｓｐ命令を用いることもできる。命令はさらに、以前に記載された態様でスタックのオーバーフロー／アンダフロー条件が生じれば、これを自動的に処理する。   When pushing a new value on the operand stack, a special increment Java operand stack pointer instruction “incjosp” must be used to ensure stack consistency. This instruction increments the operand stack pointer 102 by a specified amount N, thereby pushing all operand stack elements down by N elements. This frees up the top N element. The value going up the stack can then be moved to R7. The incjosp instruction can also be used to pop an element from the stack by decrementing the operand stack pointer. The instruction further automatically handles any stack overflow / underflow conditions that occur in the manner previously described.

さらに、Ｊａｖａ（登録商標）ローカル変数は、システムレジスタ１０４が最初の８つの変数についてそうであるように、ＲＩＳＣトラップルーチンに対してアクセス可能である。より多くの変数については、それらはメモリにおける現在のフレームにおいてアクセス可能である。   In addition, Java local variables are accessible to the RISC trap routine, as is the system register 104 for the first eight variables. For more variables, they are accessible in the current frame in memory.

図６を参照して、このプロセッサ概念を備えたシステムのための典型的なランタイム環境が示される。開発者は、通常のＪａｖａ（登録商標）コンパイラ１４２にＪａｖａ（登録商標）ソースコード１４１をコンパイルし、Ｊａｖａ（登録商標）バイトコード１４４を得ることができる。プロセッサが、ファイルローダおよび自動メモリ管理システムを備えたオペレーティングシステムを収容する場合、このプロセスの残りはダイナミックにかつ自動的に生じることができる。しかしながら、小さな組込システムはしばしばオペレーティングシステムを必要としないので、このプロセスの残りは、プログラムのメモリ画像を外部プラットフォーム上に形成しなければならないという意味で、手動で行われなければならない。Ｊａｖａ（登録商標）バイトコード１４４はリンカ１４８を通して解析しなければならない。リンカを通して走るプログラムは、（１）バイトコードがいかなる不法な命令コードも包含していないことを証明し、使用先ソリューションに依存してコードまたはオペランドを修正し、（２）アプリケーションを特定されたＪａｖａ（登録商標）クラスランタイムライブラリ１４５とリンクし、（３）アセンブリコードをＲＩＳＣ部分１４３にリンクし、ヒープ領域を設定し、ブランチアドレスおよびジャンプアドレスをセットアップし、メモリマップを作る。リンカからの出力は、組込システム１５２におけるＲＯＭまたはフラッシュメモリ１５１に転送することができるメモリイメージである。Ｊａｖａ（登録商標）プロセッサを作る目的の大部分は、プログラマができるだけ制約なくＪａｖａ（登録商標）プログラミング言語を用いることができることである。しかしながら、この場合、サポートされたタイプしか用いることができず、限定されたランタイムライブラリのみが利用可能である。しかしながらこれらの制約は、Ｊａｖａ（登録商標）の主な特徴の使用については限定的ではない。   Referring to FIG. 6, a typical runtime environment for a system with this processor concept is shown. A developer can compile Java (registered trademark) source code 141 into a normal Java (registered trademark) compiler 142 to obtain Java (registered trademark) byte code 144. If the processor contains an operating system with a file loader and an automatic memory management system, the rest of this process can occur dynamically and automatically. However, since small embedded systems often do not require an operating system, the rest of this process must be done manually in the sense that the memory image of the program must be created on an external platform. Java® bytecode 144 must be parsed through linker 148. The program that runs through the linker (1) proves that the bytecode does not contain any illegal instruction code, modifies the code or operands depending on the solution used, and (2) the application-specific Java Link with the (registered trademark) class runtime library 145, (3) Link the assembly code to the RISC part 143, set the heap area, set up the branch address and jump address, and create the memory map. The output from the linker is a memory image that can be transferred to ROM or flash memory 151 in embedded system 152. Most of the purpose of creating a Java processor is that programmers can use the Java programming language with as little restrictions as possible. However, in this case, only supported types can be used, and only a limited runtime library is available. However, these limitations are not limiting for the use of the main features of Java.

Ｊａｖａ（登録商標）ＶＭ仕様は現在２０１の命令を包含しており、その多くはタイプ固有であってさまざまなデータタイプのために本質的に複製する。ハードウェアで実現さ
れる命令の数およびトラップされる命令の数は、用いられるＲＩＳＣアーキテクチャに依存する。他の型のＲＩＳＣアーキテクチャは、ハードウェアで実現され、トラップされる多くの命令に影響する。以下の命令は、小さな組込プロセッサにおいては重要なものと考慮されないので、この発明の好ましい実施例においてハードウェアで実現されない。「浮動」タイプのすべての命令、「ダブル」タイプのすべての命令、「長い」タイプのすべての命令である。これにより、２０１のあり得るＪａｖａ（登録商標）命令からおよそ９０の命令がなくなる。残りの命令のうち、６８の命令がＪａｖａ（登録商標）仮想マシンで実現され、４３の命令がトラップされてＲＩＳＣルーチンとして実行される。トラップされ、ＲＩＳＣルーチンとして実行されたＪａｖａ（登録商標）命令は、以下の表１で示される。 The Java VM specification currently contains 201 instructions, many of which are type specific and essentially duplicate for various data types. The number of instructions implemented in hardware and the number of instructions trapped depends on the RISC architecture used. Other types of RISC architectures are implemented in hardware and affect many instructions that are trapped. The following instructions are not implemented in hardware in the preferred embodiment of the present invention because they are not considered critical in small embedded processors. All instructions of "floating" type, all instructions of "double" type, all instructions of "long" type. This eliminates approximately 90 instructions from 201 possible Java (registered trademark) instructions. Of the remaining instructions, 68 instructions are realized in the Java (registered trademark) virtual machine, and 43 instructions are trapped and executed as a RISC routine. Java instructions that have been trapped and executed as a RISC routine are shown in Table 1 below.

Figure 2008536240
Figure 2008536240

これらの実現例選択で、一般にＪａｖａ（登録商標）命令の少なくとも７０％はプロセッサにおいて直接実行される一方、最大３０％がトラップされてＲＩＳＣプログラムとし
て実行される。これらの率は動的な測定から派生し、典型的にはほとんどのＪａｖａ（登録商標）プログラムについて約９０％と１０％とになるだろう。いずれのＪａｖａ（登録商標）命令をトラップしてＲＩＳＣプログラムとして実行するべきかに関する他の選択は、ハードウェア設計およびレイテンシ要件に大部分依存して行なうことができる。 With these implementation choices, typically at least 70% of Java instructions are executed directly in the processor, while up to 30% are trapped and executed as a RISC program. These rates are derived from dynamic measurements and will typically be about 90% and 10% for most Java programs. Other choices regarding which Java instructions to trap and execute as a RISC program can be made largely depending on hardware design and latency requirements.

この発明は、トラップされたＪａｖａ（登録商標）命令の実行中、Ｊａｖａ（登録商標）オペランドスタック値へのＲＩＳＣアクセスを向上させる。レジスタ位置の再マップは、トラップされた命令のＲＩＳＣ実行がＪａｖａ（登録商標）オペランドスタックトップに正確にアクセスし、Ｊａｖａ（登録商標）状態に戻る際にトラップされた動作の結果がアクセス可能であることを確実にする。   The present invention improves RISC access to Java operand stack values during execution of trapped Java instructions. Register location remapping allows the RISC execution of the trapped instruction to accurately access the Java operand stack top, and the result of the trapped operation is accessible when returning to the Java state. Make sure.

共通のコアプロセッサ要素を共有する結合ＲＩＳＣ／Ｊａｖａ（登録商標）マイクロプロセッサアーキテクチャのブロック図である。1 is a block diagram of a combined RISC / Java microprocessor architecture that shares common core processor elements. FIG. 図１のプロセッサの正常な実行シーケンスのためのフロー図である。FIG. 2 is a flow diagram for a normal execution sequence of the processor of FIG. 1. それぞれのＲＩＳＣおよびＪａｖａ（登録商標）状態に見られるような、マイクロプロセッサのレジスタファイルの関連する部分を示すブロック図である。FIG. 3 is a block diagram showing relevant portions of a microprocessor register file, as found in the respective RISC and Java states. 図１のプロセッサをＲＩＳＣ状態とＪａｖａ（登録商標）状態との間で転移するための例示的な機構を示すブロック図である。FIG. 2 is a block diagram illustrating an exemplary mechanism for transitioning the processor of FIG. 1 between a RISC state and a Java state. トラップされたＪａｖａ（登録商標）命令をプロセッサのＲＩＳＣ状態において実行するときのこの発明の再マップ動作を示す、システムレジスタ空間およびレジスタファイルの関連する部分のブロック図である。FIG. 3 is a block diagram of the relevant portion of the system register space and register file showing the remapping operation of the present invention when executing a trapped Java instruction in the processor's RISC state. 図１のマイクロプロセッサが典型的に実現されるランタイムシステムのブロック図である。FIG. 2 is a block diagram of a runtime system in which the microprocessor of FIG. 1 is typically implemented. この発明にしたがった、プロセッサ制御部および再マップ装置を備えたマイクロプロセッサのブロック図である。1 is a block diagram of a microprocessor having a processor control unit and a remapping device according to the present invention. FIG.

Claims (23)

バイトコンパイルされたＪａｖａ（登録商標）コードをハードウェアとして実行するためのマイクロプロセッサであって、マイクロプロセッサは、
プロセッサコアと、
前記プロセッサコアにおいてＪａｖａ（登録商標）命令の第１のセットを実行するためのＪａｖａ（登録商標）制御モジュールと、
前記プロセッサコアにおいてネイティブ命令を実行するため、かつ前記プロセッサコアにおいてＪａｖａ（登録商標）命令の第２のセットをネイティブマイクロコードとして実行するための、ネイティブ制御モジュールと、
前記Ｊａｖａ（登録商標）制御モジュールおよびネイティブ制御モジュールにアクセス可能なシステムレジスタのセットとを含み、前記セットは、前記制御モジュールのいずれが所与の時間に動作可能であるかを指定するプロセッサ状態制御情報を包含する状態レジスタを含み、さらに
前記プロセッサコアのデータパスにありかつ両方の制御モジュールによってアクセス可能なレジスタファイルを含み、前記レジスタファイルは複数のレジスタ要素を含み、前記ネイティブ制御モジュールは複数のレジスタ要素をストレージレジスタとして見なし、Ｊａｖａ（登録商標）制御モジュールはレジスタ要素の第１の部分をＪａｖａ（登録商標）オペランドスタックとして、かつレジスタ要素の第２の部分をストレージレジスタとして見なし、
前記システムレジスタのセットは、現在のスタックトップである前記レジスタファイルのそのレジスタ要素を指定するＪａｖａ（登録商標）オペランドスタックポインタをも含み、前記状態レジスタはＪａｖａ（登録商標）レジスタ再マップビットをも包含し、それにより再マップビットが設定されると常に、前記第２のセットのＪａｖａ（登録商標）命令をネイティブマイクロコードとして実行する前記ネイティブ制御モジュールは、ネイティブマイクロコードで命令によって特定されるレジスタ番号をスタックトップに対して特定されたレジスタ要素に対応するよう処理する、マイクロプロセッサ。 A microprocessor for executing byte-compiled Java (registered trademark) code as hardware,
A processor core,
A Java control module for executing a first set of Java instructions in the processor core;
A native control module for executing native instructions in the processor core and for executing a second set of Java instructions as native microcode in the processor core;
A set of system registers accessible to the Java® control module and a native control module, wherein the set specifies which of the control modules is operational at a given time A status register containing information, further including a register file in the data path of the processor core and accessible by both control modules, the register file including a plurality of register elements, and the native control module including a plurality of The register element is considered as a storage register, the Java control module regards the first part of the register element as a Java operand stack and the second part of the register element as a storage register;
The set of system registers also includes a Java operand stack pointer that points to that register element of the register file that is the current stack top, and the status register also has a Java register remap bit. And the native control module that executes the second set of Java instructions as native microcode whenever a remapping bit is set is included in the register specified by the instruction in the native microcode. A microprocessor that processes numbers to correspond to register elements specified for the stack top. 前記再マップビットが設定されると常に、ネイティブマイクロコード命令によってアクセスされるスタックトップに対して対応するレジスタは、オペランドスタックポインタの最大値から、Ｊａｖａ（登録商標）オペランドスタックポインタによって特定されるレジスタ番号を引き算したものである、請求項１に記載のマイクロプロセッサ。   Whenever the remapping bit is set, the register corresponding to the stack top accessed by the native microcode instruction is the register specified by the Java (registered trademark) operand stack pointer from the maximum value of the operand stack pointer. The microprocessor of claim 1, wherein the number is subtracted. 前記再マップビットがリセットされていると常に、前記ネイティブ制御モジュールは、ネイティブ命令によって特定されるレジスタ番号をレジスタファイルの対応するストレージ要素を指定するよう処理する、請求項１に記載のマイクロプロセッサ。   The microprocessor of claim 1, wherein whenever the remapping bit is reset, the native control module processes a register number specified by a native instruction to specify a corresponding storage element in a register file. 前記再マップビットはＪａｖａ（登録商標）制御モジュールによって無視される、請求項１に記載のマイクロプロセッサ。   The microprocessor of claim 1, wherein the remapping bit is ignored by a Java control module. 前記第２のセットのＪａｖａ（登録商標）命令は前記第１のセットのＪａｖａ（登録商標）命令よりも複雑であって、前記第２のセットの命令は１つのクロックサイクル内でプロセッサコアにおいて実行されることができない、請求項１に記載のマイクロプロセッサ。   The second set of Java instructions are more complex than the first set of Java instructions, and the second set of instructions execute in the processor core within one clock cycle. The microprocessor of claim 1, which cannot be performed. Ｊａｖａ（登録商標）命令の前記第２のセットはＪａｖａ（登録商標）オブジェクトを生成したり操作したりするための命令を含む、請求項５に記載のマイクロプロセッサ。   6. The microprocessor of claim 5, wherein the second set of Java instructions includes instructions for creating and manipulating Java objects. Ｊａｖａ（登録商標）命令の前記第２のセットは長いデータタイプおよび浮動小数点データタイプで動作する命令を含む、請求項５に記載のマイクロプロセッサ。   6. The microprocessor of claim 5, wherein the second set of Java instructions includes instructions that operate on long data types and floating point data types. Ｊａｖａ（登録商標）命令の前記第２のセットはダブルタイプの命令を含む、請求項５に記載のマイクロプロセッサ。   The microprocessor of claim 5, wherein the second set of Java instructions includes double-type instructions. 前記プロセッサコアはＲＩＳＣプロセッサであり、ネイティブ命令はＲＩＣＳ命令であって、Ｊａｖａ（登録商標）命令の第２のセットを実現するためのネイティブマイクロコードはＲＩＳＣマイクロコードである、請求項１に記載のマイクロプロセッサ。   The processor core of claim 1, wherein the processor core is a RISC processor, the native instructions are RICS instructions, and the native microcode for implementing the second set of Java instructions is RISC microcode. Microprocessor. 前記レジスタファイルは、実行されるべき命令のメモリアドレスを包含するプログラムカウンタをレジスタ要素の１つとして含む、請求項１に記載のマイクロプロセッサ。   The microprocessor of claim 1, wherein the register file includes a program counter that includes a memory address of an instruction to be executed as one of the register elements. 前記レジスタファイルは、サブプログラム呼出の完了後の実行のための戻りアドレスを包含するリンクレジスタをレジスタ要素の１つとして含む、請求項１に記載のマイクロプロセッサ。   The microprocessor of claim 1, wherein the register file includes a link register that includes a return address for execution after completion of a subprogram call as one of the register elements. 前記レジスタファイルは、前記レジスタファイルが一杯である場合は常にローカル変数にアクセスするために一時的なメモリ位置を指定するためのネイティブスタックポインタをレジスタ要素の１つとして含む、請求項１に記載のマイクロプロセッサ。   2. The register file of claim 1, wherein the register file includes a native stack pointer as one of the register elements for specifying a temporary memory location to access a local variable whenever the register file is full. Microprocessor. 前記システムレジスタのセットは、前記プロセッサコアのデータパスにＪａｖａ（登録商標）ローカル変数レジスタを含み、Ｊａｖａ（登録商標）ローカル変数および前記Ｊａｖａ（登録商標）オペランドスタックの外部のパラメータの一時的な格納のためにＪａｖａ（登録商標）制御モジュールによってアクセス可能である、請求項１に記載のマイクロプロセッサ。   The set of system registers includes Java local variable registers in the processor core data path, and temporarily stores Java local variables and parameters external to the Java operand stack. The microprocessor of claim 1, accessible by a Java control module. システムレジスタのセットは、Ｊａｖａ（登録商標）命令の前記第２のセットのためのマイクロコードへのメモリ基底アドレスを包含するＪａｖａ（登録商標）トラップ基底アドレスレジスタを含む、請求項１に記載のマイクロプロセッサ。   The micro-register of claim 1, wherein the set of system registers includes a Java trap base address register that includes a memory base address to microcode for the second set of Java instructions. Processor. マイクロプロセッサにおいてＪａｖａ（登録商標）命令を実行する方法であって、前記Ｊａｖａ（登録商標）命令のサブセットは前記マイクロプロセッサにネイティブなマイクロコードとして実行され、前記方法は、
（ａ）Ｊａｖａ（登録商標）命令の第１のサブセットの前記マイクロプロセッサによる直接の実行を制御するためのＪａｖａ（登録商標）制御モジュールと、ネイティブ命令の前記マイクロプロセッサによる直接の実行を制御するためのネイティブ制御モジュールとを与えるステップを含み、前記ネイティブ制御モジュールは、Ｊａｖａ（登録商標）命令の第２のサブセットのネイティブマイクロコードとしての実行をも制御し、マイクロプロセッサはマイクロプロセッサのデータパスにおけるレジスタファイルとシステムレジスタのセットとを有し、両方とも前記Ｊａｖａ（登録商標）制御モジュールおよび前記ネイティブ制御モジュールによってアクセス可能であり、前記レジスタファイルは複数のレジスタ要素を含み、したがって前記ネイティブ制御モジュールは複数のレジスタ要素をストレージレジスタとして見なし、Ｊａｖａ（登録商標）制御モジュールはレジスタ要素の第１の部分をＪａｖａ（登録商標）オペランドスタックとして見なし、かつレジスタ要素の第２の部分をストレージレジスタとして見なし、システムレジスタのセットはＪａｖａ（登録商標）オペランドスタックポインタを含み、ポインタは現在のスタックトップであるレジスタファイルにおけるレジスタ要素を指定し、システムレジスタのセットはＪａｖａ（登録商標）レジスタ再マップビットを包含する状態レジスタをも含み、さらに
（ｂ）第２のセットのＪａｖａ（登録商標）命令が認識されるまで、Ｊａｖａ（登録商標）制御モジュールの制御下においてＪａｖａ（登録商標）命令の第１のセットをマイクロプロセッサによって実行するステップと、
（ｃ）前記第２のセットのＪａｖａ（登録商標）命令を認識する際に、そのＪａｖａ（登録商標）命令のための対応するネイティブマイクロコードにアクセスし、Ｊａｖａ（登録商標）レジスタ再マップビットを設定し、前記ネイティブ制御部に動作を引き渡してネイティブマイクロコードを実行するステップを含み、そのため、前記マイクロコードにおいてネイティブ命令を実行するとき、これらのネイティブ命令によって特定されるレジスタは、現在のスタックトップに対する前記レジスタファイルの特定されたレジスタ要素に対応するよう処理され、さらに
（ｄ）前記第２のセットのＪａｖａ（登録商標）命令のためのマイクロコード完了の際、前記Ｊａｖａ（登録商標）制御部に動作を戻し、次のＪａｖａ（登録商標）命令において実行を再開するステップと、
（ｅ）すべてのＪａｖａ（登録商標）命令が完了するまで（ｂ）から（ｄ）までのステップを繰返すステップとを含む、方法。 A method of executing Java instructions on a microprocessor, wherein a subset of the Java instructions is executed as microcode native to the microprocessor, the method comprising:
(A) a Java control module for controlling the direct execution of a first subset of Java instructions by the microprocessor, and for controlling the direct execution of native instructions by the microprocessor; A native control module that also controls the execution of the second subset of Java instructions as native microcode, wherein the microprocessor is a register in the microprocessor data path. A file and a set of system registers, both of which are accessible by the Java control module and the native control module, the register file including a plurality of register elements, and thus the The active control module regards multiple register elements as storage registers, the Java ™ control module regards the first part of the register elements as a Java operand stack, and the second part of the register elements as storage Regarded as registers, the set of system registers includes a Java operand stack pointer, the pointer specifies a register element in the register file that is the current stack top, and the set of system registers is a Java register remapping A status register containing the bits; and (b) the Java instruction's first instruction under control of the Java control module until a second set of Java instructions is recognized. 1's Performing a Tsu bets by the microprocessor,
(C) Upon recognizing the second set of Java instructions, the corresponding native microcode for the Java instruction is accessed and the Java register remap bit is set. Set and pass operations to the native controller to execute native microcode, so when executing native instructions in the microcode, the registers specified by these native instructions are the current stack top And (d) upon completion of the microcode for the second set of Java instructions, the Java controller is processed to correspond to the specified register element of the register file for In the next Java (registered trademark) instruction A step to resume execution;
(E) repeating the steps (b) to (d) until all Java instructions are completed. 前記ネイティブ制御部に動作を引き渡すステップおよび前記Ｊａｖａ（登録商標）制御部に動作を戻すステップは、状態レジスタにおけるプロセッサ状態制御情報によって仲介される、請求項１５に記載の方法。   The method of claim 15, wherein the step of passing the operation to the native controller and the step of returning the operation to the Java controller are mediated by processor state control information in a state register. システムレジスタのセットは、ネイティブマイクロコードへのメモリ基底アドレスを包含するＪａｖａ（登録商標）トラップ基底アドレスレジスタを含み、前記第２のセットの特定のＪａｖａ（登録商標）命令のための対応するネイティブマイクロコードにアクセスするステップは、その命令のために特定されたオフセットを基底アドレスに適用し、次いで結果として生じるオフセットアドレスにおいてメモリにアクセスするステップを含む、請求項１５に記載の方法。   The set of system registers includes a Java trap base address register that contains the memory base address to native microcode, and the corresponding native micro for the second set of specific Java instructions. The method of claim 15, wherein accessing the code comprises applying an offset specified for the instruction to a base address and then accessing the memory at the resulting offset address. 前記再マップビットが設定されると常に、ネイティブマイクロコード命令によってアクセスされるスタックトップに対して対応するレジスタは、オペランドスタックポインタの最大値からＪａｖａ（登録商標）オペランドスタックポインタによって特定されるレジスタ番号を引き算したものである、請求項１５に記載の方法。   Whenever the remapping bit is set, the register corresponding to the stack top accessed by the native microcode instruction is the register number specified by the Java (R) operand stack pointer from the maximum value of the operand stack pointer. The method of claim 15, wherein 前記第２のセットのＪａｖａ（登録商標）命令は前記第１のセットのＪａｖａ（登録商標）命令よりも複雑であって、前記第２のセットの命令は、１つのクロックサイクル内でマイクロプロセッサによって不可分な命令として実行されることができない、請求項１５に記載の方法。   The second set of Java instructions is more complex than the first set of Java instructions, and the second set of instructions is executed by the microprocessor within one clock cycle. The method of claim 15, wherein the method cannot be executed as an indivisible instruction. Ｊａｖａ（登録商標）命令の前記第２のセットはＪａｖａ（登録商標）オブジェクトを生成したり操作したりするための命令を含む、請求項１９に記載の方法。   20. The method of claim 19, wherein the second set of Java instructions includes instructions for creating and manipulating Java objects. Ｊａｖａ（登録商標）命令の前記第２のセットは長いデータタイプおよび浮動小数点データタイプで動作する命令を含む、請求項２０に記載の方法。   21. The method of claim 20, wherein the second set of Java instructions includes instructions that operate on long data types and floating point data types. Ｊａｖａ（登録商標）命令の前記第２のセットはダブルタイプの命令を含む、請求項２１に記載の方法。   The method of claim 21, wherein the second set of Java instructions includes double-type instructions. マイクロプロセッサはＲＩＳＣプロセッサであり、ネイティブ命令はＲＩＳＣ命令であって、Ｊａｖａ（登録商標）命令の前記第２のセットを実現するためのネイティブマイクロコードはＲＩＳＣマイクロコードである、請求項２２に記載の方法。   23. The microprocessor of claim 22, wherein the microprocessor is a RISC processor, the native instruction is a RISC instruction, and the native microcode for implementing the second set of Java instructions is RISC microcode. Method.
JP2008506461A 2005-04-15 2006-03-08 Microprocessor access using native instructions to the operand stack as a register file Abandoned JP2008536240A (en)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US11/107,235 US7478224B2 (en) 2005-04-15 2005-04-15 Microprocessor access of operand stack as a register file using native instructions
PCT/US2006/008991 WO2006112978A2 (en) 2005-04-15 2006-03-08 Microprocessor access of operand stack as a register file using native instructions

Publications (1)

Publication Number Publication Date
JP2008536240A true JP2008536240A (en) 2008-09-04

Family

ID=37109920

Family Applications (1)

Application Number Title Priority Date Filing Date
JP2008506461A Abandoned JP2008536240A (en) 2005-04-15 2006-03-08 Microprocessor access using native instructions to the operand stack as a register file

Country Status (9)

Country Link
US (1) US7478224B2 (en)
EP (1) EP1875338A4 (en)
JP (1) JP2008536240A (en)
KR (1) KR20070118663A (en)
CN (1) CN101156131A (en)
CA (1) CA2604250A1 (en)
NO (1) NO20075885L (en)
TW (1) TW200705263A (en)
WO (1) WO2006112978A2 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2016539423A (en) * 2013-11-27 2016-12-15 シャンハイ シンハオ マイクロエレクトロニクス カンパニー リミテッド Instruction set conversion system and method

Families Citing this family (17)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6332215B1 (en) * 1998-12-08 2001-12-18 Nazomi Communications, Inc. Java virtual machine hardware for RISC and CISC processors
KR20020028814A (en) 2000-10-10 2002-04-17 나조미 커뮤니케이션즈, 인코포레이티드 Java hardware accelerator using microcode engine
US7478224B2 (en) 2005-04-15 2009-01-13 Atmel Corporation Microprocessor access of operand stack as a register file using native instructions
US20070282928A1 (en) * 2006-06-06 2007-12-06 Guofang Jiao Processor core stack extension
US7979685B1 (en) 2007-11-27 2011-07-12 Oracle America, Inc. Multiple instruction execution mode resource-constrained device
CN101216756B (en) * 2007-12-28 2011-03-23 中国科学院计算技术研究所 RISC processor processor arrangement and its floating point stack manipulation simulation method
US10802990B2 (en) * 2008-10-06 2020-10-13 International Business Machines Corporation Hardware based mandatory access control
US8639882B2 (en) * 2011-12-14 2014-01-28 Nvidia Corporation Methods and apparatus for source operand collector caching
CN102722353B (en) * 2012-05-22 2015-09-23 广州晶锐信息技术有限公司 Floating-point unit of Java processor and control method thereof
US9405534B2 (en) 2013-01-21 2016-08-02 Tom Yap Compound complex instruction set computer (CCISC) processor architecture
US9110657B2 (en) 2013-01-21 2015-08-18 Tom Yap Flowchart compiler for a compound complex instruction set computer (CCISC) processor architecture
US20160381050A1 (en) * 2015-06-26 2016-12-29 Intel Corporation Processors, methods, systems, and instructions to protect shadow stacks
MA44821A (en) * 2016-02-27 2019-01-02 Kinzinger Automation Gmbh PROCESS FOR ALLOCATING A STACK OF VIRTUAL REGISTERS IN A BATTERY MACHINE
FR3070775B1 (en) * 2017-09-04 2019-08-23 Vsora DYNAMIC ALLOCATION USING MULTIPLE BATTERIES
CN111625328B (en) * 2020-05-15 2023-06-02 芯来智融半导体科技(上海)有限公司 Interrupt device, system and method suitable for RISC-V architecture
CN112199160B (en) * 2020-10-16 2021-12-28 常熟理工学院 Virtual instruction recovery method, device, equipment and storage medium
CN112199116B (en) * 2020-10-16 2023-08-11 常熟理工学院 Operand stack register identification method, device, equipment and storage medium

Family Cites Families (31)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6058473A (en) * 1993-11-30 2000-05-02 Texas Instruments Incorporated Memory store from a register pair conditional upon a selected status bit
US6076155A (en) * 1995-10-24 2000-06-13 S3 Incorporated Shared register architecture for a dual-instruction-set CPU to facilitate data exchange between the instruction sets
US5701508A (en) * 1995-12-19 1997-12-23 Intel Corporation Executing different instructions that cause different data type operations to be performed on single logical register file
KR100513138B1 (en) * 1996-01-24 2005-09-07 선 마이크로시스템즈 인코퍼레이티드 A processor for executing instruction sets received from a network or from a local memory
US6038643A (en) * 1996-01-24 2000-03-14 Sun Microsystems, Inc. Stack management unit and method for a processor having a stack
US6026485A (en) * 1996-01-24 2000-02-15 Sun Microsystems, Inc. Instruction folding for a stack-based machine
DE69734399D1 (en) * 1996-01-24 2006-03-02 Sun Microsystems Inc METHOD AND DEVICE FOR STACKING CACHE STORAGE
JP3635153B2 (en) * 1996-05-28 2005-04-06 株式会社東芝 Electron gun for cathode ray tube and cathode ray tube
US5812868A (en) * 1996-09-16 1998-09-22 Motorola Inc. Method and apparatus for selecting a register file in a data processing system
US5937193A (en) * 1996-11-27 1999-08-10 Vlsi Technology, Inc. Circuit arrangement for translating platform-independent instructions for execution on a hardware platform and method thereof
US6513156B2 (en) * 1997-06-30 2003-01-28 Sun Microsystems, Inc. Interpreting functions utilizing a hybrid of virtual and native machine instructions
US5978901A (en) * 1997-08-21 1999-11-02 Advanced Micro Devices, Inc. Floating point and multimedia unit with data type reclassification capability
US6038463A (en) * 1997-09-26 2000-03-14 Medtronic, Inc. Medical electrical lead
JP3377419B2 (en) * 1997-11-11 2003-02-17 インターナショナル・ビジネス・マシーンズ・コーポレーション Instruction string generation method and apparatus, conversion method, and computer
US6654954B1 (en) * 1998-02-17 2003-11-25 International Business Machines Corporation Computer system, program product and method utilizing executable file with alternate program code attached as a file attribute
US6256725B1 (en) * 1998-12-04 2001-07-03 Agere Systems Guardian Corp. Shared datapath processor utilizing stack-based and register-based storage spaces
US6332215B1 (en) * 1998-12-08 2001-12-18 Nazomi Communications, Inc. Java virtual machine hardware for RISC and CISC processors
US6826749B2 (en) * 1998-12-08 2004-11-30 Nazomi Communications, Inc. Java hardware accelerator using thread manager
US6338160B1 (en) * 1998-12-08 2002-01-08 Nazomi Communications, Inc. Constant pool reference resolution method
US6651159B1 (en) * 1999-11-29 2003-11-18 Ati International Srl Floating point register stack management for CISC
AU2001241487A1 (en) 2000-02-14 2001-08-27 Chicory Systems, Inc. Transforming a stack-based code sequence to a register based code sequence
US6990567B1 (en) * 2000-12-22 2006-01-24 Lsi Logic Corporation Use of internal general purpose registers of a processor as a Java virtual machine top of stack and dynamic allocation of the registers according to stack status
KR20040034601A (en) 2001-04-23 2004-04-28 아트멜 코포레이숀 Microprocessor for executing byte compiled java code
US7434030B2 (en) * 2001-09-12 2008-10-07 Renesas Technology Corp. Processor system having accelerator of Java-type of programming language
JP2003280894A (en) * 2002-03-27 2003-10-02 Hitachi Ulsi Systems Co Ltd Instruction set converter
EP1387250B8 (en) * 2002-07-31 2012-02-29 Texas Instruments Inc. Processor that accomodates multiple instruction sets and multiple decode modes
EP1387249B1 (en) * 2002-07-31 2019-03-13 Texas Instruments Incorporated RISC processor having a stack and register architecture
EP1391821A3 (en) * 2002-07-31 2007-06-06 Texas Instruments Inc. A multi processor computing system having a java stack machine and a risc based processor
EP1387247A3 (en) * 2002-07-31 2007-12-12 Texas Instruments Inc. System and method to automatically stack and unstack java local variables
US7478224B2 (en) 2005-04-15 2009-01-13 Atmel Corporation Microprocessor access of operand stack as a register file using native instructions
DK180048B1 (en) 2017-05-11 2020-02-04 Apple Inc. MAINTAINING THE DATA PROTECTION OF PERSONAL INFORMATION

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2016539423A (en) * 2013-11-27 2016-12-15 シャンハイ シンハオ マイクロエレクトロニクス カンパニー リミテッド Instruction set conversion system and method

Also Published As

Publication number Publication date
US7478224B2 (en) 2009-01-13
EP1875338A4 (en) 2008-07-30
WO2006112978A2 (en) 2006-10-26
US20060236077A1 (en) 2006-10-19
WO2006112978A3 (en) 2007-06-21
CA2604250A1 (en) 2006-10-26
CN101156131A (en) 2008-04-02
NO20075885L (en) 2007-11-15
KR20070118663A (en) 2007-12-17
EP1875338A2 (en) 2008-01-09
TW200705263A (en) 2007-02-01

Similar Documents

Publication Publication Date Title
JP2008536240A (en) Microprocessor access using native instructions to the operand stack as a register file
US11422837B2 (en) Virtual machine coprocessor for accelerating software execution
JP3786644B2 (en) Microprocessor for executing byte-compiled Java (R) code
US7243213B2 (en) Process for translating instructions for an arm-type processor into instructions for a LX-type processor; relative translator device and computer program product
US6332215B1 (en) Java virtual machine hardware for RISC and CISC processors
US9495183B2 (en) Instruction set emulation for guest operating systems
AU2004200608B2 (en) Extreme pipeline and optimized reordering technology
EP1622009A1 (en) JSM architecture and systems
JP2902402B2 (en) Data processing device
US20070033572A1 (en) Method, apparatus, and computer program product for adaptively generating code for a computer program
US20070288909A1 (en) Hardware JavaTM Bytecode Translator
JP2008510238A (en) operating system
GB2367654A (en) Translating instructions to store stack operands in registers
Probst Dynamic binary translation
EP1283465A2 (en) Transforming & caching computer programs
Fog Optimizing software in C++
Klimiankou Design and implementation of port-mapped IO management subsystem and kernel Interface for true microkernels on IA-32 processors
WO2002071211A2 (en) Data processor having multiple operating modes
JP4755371B2 (en) Computer system
Groote et al. The Raspberry Pi and the ARM processor
Feeley The CPSC 213 Companion
Standard User's Guide
Viot Meet the 68HC12
Wang et al. MTX in 32-bit Protected Mode
Penneman A virtualisation framework for embedded systems

Legal Events

Date Code Title Description
A625 Written request for application examination (by other person)

Free format text: JAPANESE INTERMEDIATE CODE: A625

Effective date: 20090306

A521 Written amendment

Free format text: JAPANESE INTERMEDIATE CODE: A523

Effective date: 20090407

RD02 Notification of acceptance of power of attorney

Free format text: JAPANESE INTERMEDIATE CODE: A7422

Effective date: 20090527

RD03 Notification of appointment of power of attorney

Free format text: JAPANESE INTERMEDIATE CODE: A7423

Effective date: 20090527

A521 Written amendment

Free format text: JAPANESE INTERMEDIATE CODE: A821

Effective date: 20090605

RD04 Notification of resignation of power of attorney

Free format text: JAPANESE INTERMEDIATE CODE: A7424

Effective date: 20090605

A762 Written abandonment of application

Free format text: JAPANESE INTERMEDIATE CODE: A762

Effective date: 20100203