CN1570870A

CN1570870A - 终极管道和最优重排技术

Info

Publication number: CN1570870A
Application number: CNA200410006961XA
Authority: CN
Inventors: E·W·兹沃纳; G·P·克劳克; J·C·肯耐尔; T·R·郝瑞格; W·J·坎农
Original assignee: Northrop Grumman Corp
Current assignee: Northrop Grumman Corp
Priority date: 2003-03-13
Filing date: 2004-03-01
Publication date: 2005-01-26
Also published as: EP2290537A2; US8423976B2; AU2004200608B2; EP2290537A3; US20040181785A1; TW200504595A; RU2004107417A; AU2004200608A1; CA2456244A1; TWI252431B; JP2004280795A; EP1457881A1; KR20040081379A

Abstract

本发明为一种终极管道和最优重排技术，涉及用于将针对遗留处理器编写的二进制指令直接转换为本机处理器可执行的二进制指令的二进制代码转换器。按照本发明的一个重要方面，将所述二进制代码转换器配置成为一种可重新配置的代码转换器，这使得该二进制代码转换器能够用于不同的遗留处理器和/或操作系统和本机处理器。该二进制代码转换器还进行优化，以利用更有效的本机处理器指令，并允许禁用部分遗留二进制代码和/或将新的本机指令加入到应用程序中而无需改变遗留二进制代码。

Description

终极管道和最优重排技术

技术领域

本发明涉及一种二进制代码转换器，该代码转换器用于将遗留处理器的二进制代码直接转换为本机处理器可执行的二进制代码，并且更加具体地讲，涉及一种形成为可重新配置的代码转换器的二进制代码转换器，这适合于用于不同的遗留处理器和/或操作系统以及不同的本机处理器，在该转换器中可对遗留代码进行静态转换、动态转换或即时转换，并且允许插入新的代码或禁用部分遗留代码，而不对遗留二进制代码进行修改。

背景技术

我们都知道，微处理器是利用不同的指令系统体系结构(ISA)配置的。ISA为具体的微处理器确定了指令系统。由微处理器执行的应用程序通常是用称作源代码的相对高级语言写成的，例如用C或C++，并将这些应用程序编译为与具体的微处理器的指令系统相符的机器指令。这些机器指令称为二进制代码、目标码和可执行代码。

归因于许多现有微处理器的老化和陈旧以及它们相应的低速度，经常需要用更新更快的微处理器(这里称为“本机微处理器”或“本机处理器”)来更换过时的现有微处理器(下文中称为“遗留微处理器”和“遗留处理器”)。可惜，依靠于升级，本机处理器的指令系统时常与遗留处理器的指令系统不兼容。同样地，已经开发出了多种多样的使针对遗留处理器编写的应用程序能够在更新的本机处理器上应用的技术。例如，我们已经知道的软件仿真程序。这种软件仿真程序是建立在对应用程序中所使用的遗留处理器的各种机器代码指令进行仿真的基础上的。我们知道这样的仿真器包括多个由一个或多个本机指令组成以实现与所仿真的遗留指令相同的功能的软件处理程序。在共同拥有的美国专利第6041402号、第6212614号和第6272453号以及2003年3月6日申请(摘要第20-0169号)的名称为《直接指令翻译仿真计算机技术(Direct Instruction Rendering Emulation ComputerTechnique)》的共同拥有的美国专利申请序列号第＿＿号中，公开了这样的指令仿真程序系统的实例。

还有一些原因表明了为什么需要二进制代码转换器。首先，可能无法利用遗留源代码向现代计算机体系结构实现软件移植。其次，与传统的仿真系统相关的软件系统开销显著地减缓了处理速度。于是，对于遗留代码在更新的、不兼容的硬件平台上的再使用来说，二进制代码转换是唯一可行的选择。

这种二进制代码转换器将遗留处理器的二进制代码直接转换为本机处理器的二进制代码。在美国专利第6223339号、第6314560号和第6502237号中公开了这种二进制代码转换器的例子。而且在于1997年2月23日-26日在加利福尼亚圣何塞召开的97年计算机会议论文集(Compcon’97 proceedings，IEEE)中的第37-42页的由数字设备公司(Digital Equipment Corporation)的R.Hookway所著的《在Alpha NT上运行32位x86应用程序的DIGITAL FX！32(DIGITAL FX！32 Runningon 32-bit x86 Application on Alpha NT)》、2001年11月出版的IEEE学报第11期第89卷第1710-1722页中的Altman等人所著的《二进制代码转换及优化进展与未来前景(Advances and Future Chanllenges inBinary Translation and Optimization)》、数字技术杂志(Digital TechnicalJournal)1997年第1期第9卷第1-12页中的由Hookway等人所著的《数字FX！32：仿真与二进制代码转换的结合(Digital FX！32：CombiningEmulation and Binary Translation)》、计算机杂志(Computer Magazine)2000年3月第33卷第47-52页上的由Zheng等人所著的《PA-RISC到IA-64：透明执行，无需再编译(PA-RISC to IA-64：TransparentExecution，No Recompilation)》这些文献中也公开了二进制代码转换器。

虽然已知的二进制代码转换器能够将遗留二进制代码有效地转换为本机二进制代码而无需修改遗留二进制代码，但是却存在着与这些已知的二进制代码转换器相关的问题。例如，绝大多数二进制代码转换器都是为单一的遗留/本机处理器和操作系统的组合而开发的。因此，在不同的遗留处理器和/或本机处理器上运行的应用程序将需要单独的代码转换器。此外，这些已知代码转换器不允许为了实现禁用部分遗留代码或无需重新编译程序地对其进行增强的目的而添加用现代程序设计语言编写的新本机代码，这要求有权使用原始源代码。因此，存在着对适用于多种遗留处理器和本机处理器和/或操作系统并且在遗留和本机指令层面上都可以进行模块化优化同时允许无需重新编译遗留程序地添加新的本机代码的一种用于将遗留二进制指令转换为本机指令的二进制代码转换器的需求。

发明内容

本发明涉及一种用于将针对遗留处理器编写的二进制指令直接转换为本机处理器可执行的二进制指令的二进制代码转换器。按照本发明的一个重要方面，所述二进制代码转换器是一种可重新配置的代码转换器，这使得该二进制代码转换器能够用于遗留处理器和/或操作系统以及本机处理器的不同组合。还对该二进制代码转换器进行优化，以利用更有效的本机处理器指令和可用功能，并允许禁用部分遗留二进制代码和/或将新的本机指令加入到应用程序中而无需改变遗留二进制代码。

附图说明

参照后面的说明和所附的附图，将会更加容易地理解本发明的这些和其它的优点，其中：

附图1是一个示范性软件模型的框图，它说明了应用程序是如何与系统操作系统和处理器相互作用的。

附图2是一个框图，它说明了按照本发明的一个方面的用于将二进制指令插入到本机指令组中的thunk过程。

附图3是按照本发明的二进制代码转换器的框图，对其各个子系统进行了说明。

附图4是为了在运行Linux操作系统的本机Intel IA-64处理器上使用而用于对针对Tru64 Unix操作系统编写的示范性遗留Alpha 21264微处理器应用程序进行转换的示范性载入程序程序表。

附图5是表示示范性遗留代码段和向量空间之间的关系的示范性存储器分配图。

附图6是表示用于按照本发明的二进制代码转换器的存储器配置的示范性示意图。

附图7是用于按照本发明的二进制代码转换器的类图。

附图8是用于按照本发明的二进制代码转换器的分级类图。

附图9是按照本发明的二进制代码转换器的过程图。

附图10是按照本发明的用于IA-64微处理器的调度优化程序的框图。

附图11是按照本发明的示范性指令调度优化程序算法的流程图。

附图12是表示Alpha遗留二进制指令到Intel IA-64本机处理器二进制指令的示范性指令转换的框图。

附图13表示用于Intel IA-64本机处理器的指令束格式。

附图14表示一个标准型Itanium 2处理器的执行单元格式。

附图15表示如何将两个IA-64指令组中的第一个中的经转换的IA-64本机处理器指令组织为IA-64指令束。

附图16与附图15相类似，只是表示对两个IA-64指令组中的第二个的处理过程。

附图17表示按照本发明的转移判定优化方法实例。

具体实施方式

本发明涉及一种形成为可重新配置的代码转换器的二进制代码转换器，该代码转换器能够将遗留微处理器的二进制指令直接转换为本机处理器的二进制指令。遗留处理器的二进制指令的直接转换得到本机二进制指令，这样通常要比对遗留指令进行仿真执行起来快得多。此外，依照本发明的一个重要方面，能够对该系统进行配置以应用于多种本机处理器、多种遗留处理器和操作系统。为了进一步提高经转换的本机程序的适应性，可以使用thunk对象来禁用部分遗留二进制指令和/或插入新的本机指令而无需改变原始的遗留二进制代码。如后面将要详细讨论的，按照本发明的二进制代码转换器是这样将遗留二进制代码转换为本机二进制指令的：首先将遗留二进制指令分组为连续执行的代码段、实施算法优化，然后将这些二进制指令一条一条地转换为本机指令系统。一旦完成了指令转换，如果需要的话，还可以执行本机优化程序。取决于本机处理器，可以对本机二进制指令进行重排和/或分组，以充分利用可用的处理器资源。所得到的本机二进制指令因此能够在本机平台上独立执行。

按照本发明的二进制代码转换器是以三种不同的工作模式进行工作的：静态转换模式，在该模式下，脱机地完成转换以生成新的可执行本机指令的二进制代码；动态转换模式，在该模式下，转换是在将遗留二进制代码载入本机处理器存储器中的同时进行的；还有一种即时转换模式，在该模式下，当且仅当首次执行遗留指令需要对他们进行转换的时候才对这些遗留二进制指令进行转换。

虽然将按照本发明的二进制代码转换器形成为可重新配置的代码转换器，其可以为了用于各种遗留的和本机的处理器而进行配置，但是本发明的示范性实施例是一个使用Tru64 Unix操作系统的Alpha21264微处理器和一个使用Linux操作系统的Intel IA-64本机处理器。该Alpha 21264微处理器是一个精简指令系统计算机(RISC)。使用RISC体系结构配置的微处理器一般在寄存器中执行所有的指令。载入和存储指令用于将数据取入寄存器和将结果保存回存储器中。出于这一原因，RISC体系结构被称为“载入/存储”体系结构。RISC体系结构还排除了复杂的指令，以降低硬件的复杂程度。现代软件设计模式促进了高级语言的使用并且编译器一般不使用复杂的指令。

所述Intel IA-64微处理器采用了一种相对较新的设计模式，称为显性并行指令计算机(EPIC)。这种EPIC体系结构规定：用于最佳性能的调度指令是由编译器(或汇编语言编程器)完成的，而不是微处理器硬件。IA-64采用了一些功能部件来消除或减小处理器性能问题的范围。例如，这种IA-64处理器包含有相对较大的寄存器组；消除短正向转移的能力；以及相对较大的执行单元数量，以提高并行代码执行能力。该IA-64微处理器包括一个不断壮大的微处理器家族。下面的说明涉及一种称为Itanium 2的标准型IA-64处理器。

应用软件模型

参照附图1，示出了一个现代软件应用系统的层次模型。该模型包括一个应用软件层20、一个系统程序库层22、一个操作系统层24和一个硬件层26。现代软件应用系统程序20通常是为了在特定的微处理器体系结构和操作系统上运行而编写的。如图所示，应用软件20利用微处理器操作系统24的服务程序以及一组系统程序库22来执行通用任务。具体来说，该应用软件可以直接请求操作系统调用，如箭头28所示，不过更一般地是借助系统程序库调用与系统程序库22进行联系，如箭头30所示。顺次地，系统程序库22典型地向操作系统层24请求系统调用，如箭头32所示。例如，标准C/C++系统程序库层22包含利用C函数处理磁盘文件的能力。这些函数依次地通过系统调用与操作系统相互作用。如下面将要详细讨论的，按照本发明的二进制代码转换器与底层操作系统发生联系而不需要与遗留和本机操作系统发生联系。

二进制代码转换器子系统

参照附图3，按照本发明的二进制代码转换器是由四个模块化的且可重新配置的子系统组成的：一个装入程序子系统34、一个遗留指令处理程序子系统36、指令转换器子系统38和一个本机指令处理程序子系统40。每个子系统34、36、38和40都是例如用C++写成的模块化对象。照此，任何一个子系统34、36、38和40都可以围绕一个具体的本机处理器体系结构、一个遗留处理器体系结构或者二者全部来进行设计。照此，按照本发明的二进制代码转换器是可重新配置的，就是说它可针对任何遗留的或本机处理器而进行配置，而不象公知的二进制代码转换器那样是针对一个具体的遗留/本机处理器组合而配置的。

后面将给出每个子系统的详细讨论。不过，总地来说，所述载入程序34从遗留二进制文件中读取遗留代码和数据段。所述遗留指令处理程序子系统36对这些遗留指令加以分类并将遗留程序分解为遗留进程。此外，如果存在任何转换前优化模块并且它们是有效的，那么将会对它们进行调用。所述指令转换器子系统38将那些遗留指令转换为本机指令。所述本机指令处理程序子系统40调用转换后优化模块，如果有这样的模块的话，并将所得到的完全转换的程序写入本机处理器存储器或磁盘文件中，以进行后续运行。

按照本发明的二进制代码转换器另外还允许将代码优化模块插入到子系统36或40中，以进一步提高系统性能。参照附图9，这些模块由附图标记64和66标示。可以存在任意数量的优化模块，它们可以对转换前遗留代码、转换后遗留代码或它们的某种组合进行操作。如果需要，也可以除去这些优化模块。

按照本发明的二进制代码转换器还考虑到了将新的本机代码插入到转换后的遗留代码流中。这些新的本机代码字段称为“thunk”。附图2中示出了一个thunk 42。这些thunk对象42可用于为了实现各种目的而增加功能，而无需改变已有的二进制代码，例如增加新的功能或禁用部分原始的遗留代码。如附图2所示，示出了三个本机指令组块44、46和48。Thunk代码是借助从本机指令代码44指向thunk对象42的向量插入的。执行thunk对象42中的thunk代码。一旦完成了thunk代码的执行，如附图2所示，系统引导返回到本机指令组。

载入程序子系统

如上面所提到的，所述载入程序子系统34读取遗留二进制文件并提取遗留代码和数据段。该载入程序子系统34是一个可插入系统，它能够适用于多种文件格式。对于上面所提到的示范性遗留处理器和操作系统来说，示范性的载入程序包括Linux可执行和连接格式(ELF)和Tru64 Unix公用对象文件格式(COFF)。

所述载入程序子系统34仅通过少数几个接口程序与二进制代码转换器的平衡进行联系。附图4表示在对使用Tru64操作系统的Alpha遗留微处理器的指令到使用Linux操作系统的Intel IA-64微处理器的转换中所使用的一个示范性的通用建模语言(UML)程序表。

遗留指令处理程序子系统

所述遗留指令处理程序子系统36对遗留指令进行分析、按照它们的一般职能确定它们的类型并将这些指令分解为遗留代码的功能块。在遗留指令处理程序子系统36失去控制权之前，它能够调用任何所需的可用的且有活性的遗留优化程序。遗留指令处理程序子系统36独立于运行着系统的本机处理器。

遗留指令处理程序子系统36将遗留程序分解为多个段，称为遗留进程。一个遗留进程是一段以遗留流程控制指令结束的遗留指令，例如转移指令。每个遗留指令被放置在一个container对象中，称为“LegacyInstruction”。该LegacyInstruction对象保存在“LegacyProcedure”对象中。如后面将要详细讨论的，在靠后的阶段中，将把“NativeInstruction”添加到LegacyProcedure对象中。

每个LegacyInstruction对象含有遗留二进制指令以及关于该指令的信息，该信息包括其总体类型以及如何将其转换为本机处理器指令。然后container对象可用于在转换和优化中所使用的其它子系统。所有的遗留进程对象都包含在一个LegacyProgram对象中。

遗留指令处理程序36是一个模块化子系统并且将其配置得与不同的遗留处理器实现兼容。这可以通过C++对象定向技术来实现。存在基本类以定义所需的接口程序。

在对遗留指令进行了分组和确定了类型之后，遗留处理程序子系统36在退出之前调用任意所需的转换前优化模块并且有许多的优化模块可供选择执行。转换前优化模块对遗留指令起作用并且可以禁用它们，扩充它们，或者与转换后优化程序相结合产生更好的执行代码。

指令转换器子系统

所述指令转换器子系统38进行从遗留处理器指令到本机处理器指令的转换。该子系统38依赖于遗留和本机处理器体系结构。该子系统38是由其它子系统进行调用的，并且含有执行如下所述的两个主要功能的指令转换对象：

● 指令类型确定。遗留指令处理程序36使用指令类型确定判定遗留指令的类型。这种结构方式指示遗留指令处理程序此时它遇到了一个遗留流程控制指令并且提供转换前优化程序可能需要的类型信息。

● 指令转换。本机指令处理程序子系统36使用这一服务来产生执行遗留指令所要求的操作的本机处理器指令。

所述指令转换器子系统38最终负责执行所有的遗留到本机的指令转换。

在本发明的一个示范性的实施例中，其中将Alpha遗留微处理器的二进制指令转换为用于Intel IA-64微处理器的适当的二进制指令，该指令转换器子系统38可以由一系列的C函数实现-每一个函数对应于各个Alpha遗留指令来产生所需的IA-64本机处理器指令。这些C函数此后称为遗留指令转换器。另外，一系列的C函数，每一个函数对应于一个所需的IA-64遗留本机处理器指令，可以从所述遗留指令转换器内部使用。这些C函数下文中称为本机指令发生器。

本机指令处理程序子系统

所述本机指令处理程序子系统40请求遗留指令到本机指令的转换、调用任何需要的本机指令优化模块并将经转换的二进制代码写入到本机处理器存储器或一个文件中以备今后使用。

本机指令对象用于保存重复遗留进程的行为所需的本机指令。一个遗留进程所需的本机指令对象的数量可以与或不与遗留指令对象的数量相匹配，这是因为重复遗留指令的行为所需的本机指令的数量是变化的。所有的本机指令对象，作为一个整体，是经转换的二进制程序的指令部分。

本机指令处理程序子系统40完全可配置为能够使遗留二进制指令在各种各样不同的本机处理器上执行的子系统。这个子系统40独立于正在使用的遗留处理器工作。

如前面所提到的，借助指令转换器子系统38进行的指令转换是由本机指令处理程序子系统40调用的。这一过程包括将一定数量的本机指令对象加入到已经产生的遗留进程对象中，这些本机指令对象含有经转换的主处理器指令。此时本机指令没有提交给存储器或文件，这是因为转换后优化程序可能会改变本机指令组合。

在每个遗留指令都已经转换为一个或多个本机处理器指令之后，将调用所存在的任意转换后优化程序。这些可插入模块可能是激活的或停用的。

转换过程

如上面所提到的，将遗留程序分解为由遗留流程控制指令结束的遗留进程。这允许同时对多个指令进行处理，以得到较佳优化的代码。例如，Intel IA-64体系结构每时钟周期允许执行多达六条指令。同时处理多个指令允许根据数据相关性判断哪些指令对于并行执行是安全的。结果，为遗留指令字段或进程生成的那些本机指令可以不执行与遗留处理器顺序完全相同的操作。不过，只要考虑到了数据相关性，这就并不成其为问题了。然而，一次一条地执行Intel IA-64指令，是无法充分利用该处理器的运行资源的。

按照本发明的二进制代码转换器使用一个向量表或向量空间，其含有与每条遗留指令相对应的64位值。这些64位值是用于每条指令的本机指令处理程序的完整地址。不过，并不是每条指令都含有一个有效的向量条目，这是由于遗留指令均被分解为以遗留流程控制指令结束的遗留代码字段。由于按照本发明的二进制代码转换器是以连续执行遗留代码块或字段的方式工作的，因此仅仅每个相应的遗留代码字段(或遗留进程)的开端需要一个向量。该向量就是用于某个进程的本机指令处理程序的地址。例如，附图5表示由附图标记50和52标出的两组遗留指令及其地址。每组指令50、52以一个转移指令BEQ结束，它们组成了一个遗留代码字段(或遗留进程)。每个遗留地址在所述向量空间中具有一个相应的位置。依次地，每个在所述向量空间中占有一席之地的条目都指向微码空间中的一个本机指令处理程序。按照本发明的一个方面，在处理转移指令的时候，二进制代码转换器使用一个双处理周期转换系统。更具体地讲，对于许多遗留转移指令来说，直接从遗留代码中确定转移目的地是可能的。而另外一些情况下，目的地代码是无法直接确定的。按照本发明的二进制代码转换器对这两种情况均能处理。

转换的第一个处理周期为所有遗留指令产生本机指令，只是除了跳转或转移指令(即流程控制指令)。一旦完成了第一个处理周期，就可以完成相关的转移指令的转换了，这是由于其余的代码都已经产生了。第二个处理周期为那些目的地可以在转换的时候得到确定的转移填补转移指令。

如果可以在转换的时候确定转移目的地并且该转移指向一个没有有效向量的位置的话，则产生一个LegacyProcedure对象并从那一点开始向前装入遗留指令直到找到遗留流程控制指令。例如，参照附图5，如果一个已结束的转移转到位置1020，则将会产生一个LegacyProcedure对象并且该对象会为位于地址1020、1024和1028的指令进行转换。这一处理是在第二个处理周期期间发生的。因此，该第二个处理周期为载入时获知的目的地完成了所有转移指令并且为还不具有有效向量的目的地建立了新的处理器。

虽然所述双处理周期转换能够处理许多转移指令，但是在载入时并不是所有的转移目的地都得以获知。某些转移指令依赖于运行时计算出来的目的地地址。在这些情况下，这些转移指令从向量空间中获取它们的本机指令处理程序地址并跳转到这些位置。如果没有针对该目的地的有效向量，则动态地产生一个本机指令处理程序并且将其地址加入到所述向量空间中。这一过程是借助动态尝试来完成的，所述动态尝试从转移目的地地址开始并连续进行遗留代码的运行同步转换，直到找到一个遗留流程控制指令。该动态尝试对象建立一个新的LegacyProcedure对象并将用于遗留指令的LegacyInstruction对象装入其中，直到下一个流程控制指令。然后它请求遗留指令的转换并将所得到的本机指令提交给存储器。这个系统能够处理所有的转移指令，但是由于进行转移目的地的预计算能够实现更好的性能，所以该系统只是用作最后使用的手段。

操作系统调用

如上面所提到的，我们知道应用程序是通过系统程序库函数直接地或间接地进行操作系统调用的。例如，Alpha 21264微处理器体系结构将系统调用定义为一种特定指令。该指令在执行的时候引发一个操作系统中断。在系统调用指令之前，编译器和/或编程器必须将系统调用号插入到一个已知的寄存器中，在Alpha 21264微处理器的情况中是$v0。系统调用号从$v0中提取出来并且其它的参数可以从按照系统的函数调用惯用手段定义的其它寄存器中提取出来。对于二进制代码转换器而言，系统调用仅仅是另一个指令而已。不过操作系统之间的系统调用号可以是也确实是不同的。举例来说，OpenVMS操作系统与Tru64 Unix就使用了不同的系统调用号。用于Alpha的Windows NT操作系统也不同于OpenVMS和Tru64。因此，所述二进制代码转换器系统调用对遗留操作系统来说必须是特定的。

直接匹配系统调用

所述二进制代码转换器能够将每个系统调用映射为接近匹配的主处理器系统调用或者在或不在本机操作系统的帮助下对遗留系统调用的行为进行仿真的代码。例如，针对Intel IA-64微处理器体系结构编写的，用于将移除磁盘路径(rmdir)Alpha Tru64 Unix系统调用转换为等效的Intel IA-64 Linux系统调用的示范性汇编语言程序在下面示出：

    /*

     *SYS_rmdir

     *Alpha 137＜---＞IA-64 l056

     *

     *Inputs：r32＝char *pathname

     *Outputs：int status

     */

    .proc xport_SYS_rmdir

    xport_SYS_rmdir：

       MapPreamble  r86，rTemp1，bSave1   // setup，save return address

       MakeIA64Addr param0，a0            // setup first input

       mov          r15＝1056             // setup the syscall number

       break        0x100000              // do syscall

       AdjustResults                      // fixup errno/indicator

       Return       bSave1                // done，return

    .endp

这一承接程序的地址保存在一个表中，并且当执行Alpha 21264系统调用指令时，处于Alpha寄存器$v0中的系统调用号用作进入该表的索引。在该表位置处的所述地址用于转移到这承接程序。这一承接程序仅将所需的参数(指向含有目录名的字符串的指针)移送到Intel型IA-64处理器上的校正寄存器中，并将IA-64系统调用号(1056，而不是Alpha微处理器中的137)放到Intel IA-64微处理器中的寄存器15中。该系统调用返回一个指示值，代表成功的0或代表失败的-1，该值被置于Alpha微处理器中的校正寄存器中。另一个值，“errno”(错误号error number)表示失败的原因。这个值在Alpha/Tru64系统和IA-64/Linux系统之间是互不相同的，因此必须要对这个值进行转换。“AdjustResult”宏指令借助另一个数据表来完成这一任务。一旦完成了转换，errno值就被置于校正Alpha寄存器，并且承接程序准备返回到常规的代码执行。IA-64中断指令使用参数0x100000引发这一系统调用。

非直接匹配系统调用

前面所述的例子说明了一种对现有的主处理器系统调用存在严格匹配的情况。不过，并不总是这样的。例如，Alpha/Tru64 Unix“uname”系统调用是以多个文本流的形式返回关于机器的信息的。下面的例子就是这种系统调用的汇编语言承接程序的一个例子。

    /*

     *SYS_uname  

     *Alpha 207＜---＞IA-64 1130

     *

     *Inputs：r32＝struct utsname *buf

     *Outputs：int status

     */

    .proc xport_SYS_uname

    xport_SYS_uname：

       MapPreamble       r86，rTemp1，bSave1 //  setup，save return address

       MakeIA64Addr      param0，a0          //  setup first input(sysname)

       br.call.sptk.few  b0＝callsysUname    // do as a C function

       cmp·eq           pTemp1，pTemp2＝0，IA64Ret //was return value good？

    (pTemp1)mov          v0＝0                //yes，fix up errno

    (pTemp1)mov          a3＝0                //   and error indicator

    (pTemp2)mov          v0＝14               //no，set errno to EFAULT

    (pTemp2)mov          a3＝-1               //   and error indicator to -1

       Return            bSave1               //done，return

    .endp

对这一系统调用直接进行映射的问题是，遗留程序不是在处理器上运行的，因为最初就是这样设计的。因此，这一承接程序调用一个C函数而不是直接使用Intel IA-64 Linux“uname”系统调用并对所得到的字符串进行调整。

下面的例子表示用于对Linux“uname”系统调用的行为进行重定义的C函数。注意：这一函数是由上面的承接程序中的br.call.sptk.few指令调用的。

    /*

     *This is a stub for the uname system call.Additional work must be

     *done for two reasons：1)the size of the strings in the utsname

     *struct is different between IA-64/Linux and Alpha/OSF，and 2)we

     *really don’t want an Alpha/OSF program thinking it’s running on

     *IA-64/Linux.

     */

    INT64 callsysUname(char *uts_alpha)

    {

       struct utsname uts；

       //do the syscall，see if it works

       if(uname(&amp;uts)<0)

         return-1；

       //this doesn’t work directly because the IA-64 utsname struct allows

       //for each string to be 64 bytes but the Alpha only allows for 32

       //ALSO--FAKE IT OUT TO LOOK LIKE THE ALPHA!

       strcpy(&amp;uts_alpha[0]，“OSF1”)；

       strcpy(&amp;uts_alpha[32]，uts.nodename)；

       strcpy(&amp;uts_alpha[64]，“VS.1”)；

       strcpy(&amp;uts_alpha[96]，“732”)；

       strcpy(&amp;uts_alpha[128]，“alpha”)；

       return 0；

    }

需要注意的是：虽然使用了Linux“uname”系统调用，但是只有‘nodename，项传送给了本机结果。虚拟了所有其它的信息组以使得该程序相信它自己是在Tru64 Unix操作系统上运行，例如，版本5.1，build 732。

通过象这样的技术，能够重新生成遗留操作系统的整个系统调用组。这一任务的复杂程度取决于遗留和本机操作系统之间的差异。对于Tru64操作系统上运行的Alpha微处理器与Linux操作系统上运行的Intel IA-64微处理器之间进行转换的情况，它们之间存在着许多的相似之处。

系统程序库的替换

如上面所讨论的，可以将系统调用映射到主操作系统中。如上面所提到的，遗留应用程序还与系统程序库进行联系。取决于遗留应用程序，使用本机处理器的系统程序库而不是遗留程序库是有可能的。这种方法的优点在于：本机程序库有望更好地适于在本机系统上执行。如果不能使用本机程序库，那么就必须以一种或另一种形式使用遗留程序库。

静态与动态链接

使用系统程序库的软件应用程序可以是静态链接的，也可以是动态链接的。对于静态链接来说，从程序库中得到的应用程序所需要的代码都送入到最终得到的应用程序二进制代码载入模块中。这生成了一个很好的但是比动态链接要大的载入模块，动态链接是根据需要载入程序库代码的。对于动态链接的应用程序，在程序运行的时候，必须要用到一个共享程序库。

静态链接应用程序

如果遗留应用程序是静态链接的，那么将有可能无法简单地用本机程序库代码替换静态链接的遗留程序库代码。因此，可以利用遗留应用程序的间歇期对遗留程序库代码进行转换。按照本发明的二进制代码转换器将不会知道遗留程序库代码的存在。不需要额外的遗留组件来产生完全转换的本机二进制代码。

动态链接应用程序

对于使用动态程序库链接的应用程序来说，载入模块必须含有关于需要哪个程序库的信息。而且还将给出有关哪些函数是未加解决的函数的信息。就这点来说，通常能够使用本机程序库替代遗留程序库。这种替代是否能够实现取决于在本机系统上是否存在相同的功能性。如果这样做了，就需要使用一个简单的转换承接程序来将参数转移到校正寄存器中，这是由于遗留处理器和主处理器之间的函数调用协定很可能互不相同。下面的代码实例表示一个Intel IA-64汇编语言承接程序的例子，该程序允许使用本机‘atan’(arctangent反正切函数)库函数代替遗留库函数。

    //double atan(double x)；

    .proc atanXport

    atanXport：

       MapPreamble        ra，rTemp1，bSave1     // Save IA64 return addr in bSavel

       mov                fout0＝fa0             // Move arg0

       br.call.sptk.many  b0＝atan               // Call ia64 routine

       mov                LegacyFpRet＝IA64FpRet // Move IA64 return value to legacy

       Return             bSave1                 // Return

    .endp

如上所示，仅需要非常少的代码就能够将Intel IA-64‘atan’库函数映射为Alpha版本，同时所得到的性能较之使用数量相对较大的代码而言得到了提高。不过，这种方法要求能够对遗留库函数进行识别并且要知道它需要那些参数。因此，它仅适用于常用库函数，而不能用于未知的遗留程序库。

将遗留函数映射为本机函数的另一种方案是简单地对遗留程序库进行代码转换。这显然要求遗留程序库可用于代码转换。这种处理方法得到与静态链接应用相同的结果，只是比使用本机程序库要复杂一些，这是因为任何可用到的遗留程序库都将要被使用，不管其所含有的函数是否已知。

存储器配置

附图6是按照本发明的二进制代码转换器中所使用的存储区域的图解表示。用附图标记54和56标示的最前面的两个存储区域是第一个处理周期和第二个处理周期微码区域，如上面所讨论的。这些存储区域含有经转换的本机指令，这些指令组成了经转换的遗留应用程序。由附图标记58标示的下一个区域是含有每个遗留指令处理器的微码地址的向量空间。如上面所预先指明的，并不是该向量空间中的所有位置都含有有效的条目。该向量空间58所含有的条目的数量与遗留代码指令的数量相同。最后那个区域是数据空间60。这些是所述遗留应用程序载入模块中所定义的数据部分。该数据空间60仅仅用于静态数据或在载入模块中进行了明确定义的数据。遗留程序可以根据需要从堆阵中或自由存储空间中指派存储器。

根据需要，其它的存储区域也可以提供给经转换的遗留应用程序。这些存储区域包括堆栈，该堆栈是从本机处理器存储器组合中划拨出来的并且从主处理器堆阵或自由存储空间中动态地请求存储空间。

另一个可能存在的区域，它可以或不可以物理地位于所述主处理器存储器中，是遗留代码。除了上面所讨论的动态尝试操作以外，一旦完成了代码转换，就不再需要这一信息。在这些情况下，可以从一个磁盘文件中将这一信息读入到保存存储器中。

寄存器配置

按照本发明的二进制代码转换器在性能方面一个主要的因素是其使用本机处理器寄存器的方法。下面将给出关于按照本发明的二进制代码转换器如何使用本机处理器的寄存器进行其遗留二进制代码的执行的信息。对于不同的本机处理器来说这一信息可以是不同的。下面的信息是与Intel IA-64本机处理器和Alpha 21264遗留处理器相关的信息。

为了性能的缘故，将遗留处理器寄存器映射到本机处理器寄存器。许多现代微处理器体系结构专门在寄存器中执行几乎所有的操作并且被迫从存储器中载入值然后再没必要地将结果保存回去，导致了相当严重的性能恶化。

Alpha 21264处理器具有32个64位通用寄存器和32个64位浮点寄存器。Intel IA-64处理器具有128个64位通用寄存器和128个80位浮点寄存器。下面将给出Alpha/Tru64遗留系统和IA-64本机系统的寄存器配置。

将通用寄存器0-30中的值存储在IA-64通用寄存器32-62中。

Alpha通用寄存器31总是读为零并且能够对其写入，但是其值总是读出零。IA-64通用寄存器0具有几乎相同的特性，因此将Alpha寄存器31映射为Intel IA-64通用寄存器零。

将浮点寄存器0-30中的值存储在IA-64浮点寄存器32-62中。

Alpha浮点寄存器31总是读为零并且能够对其写入，但是其值将总是读出零。IA-64浮点寄存器0具有几乎相同的特性，因此将Alpha浮点寄存器31映射为Intel IA-64浮点寄存器0。

将16个IA-64通用寄存器指定为便笺式或临时寄存器r63-r78。

将16个IA-64浮点寄存器指定为便笺式或临时寄存器f63-f78。

将16个IA-64判定寄存器指定为便笺式或临时寄存器p1-p16。判定寄存器用于存储比较操作所得到的单位true/false结果。这些寄存器可以与几乎所有的IA-64指令的执行相对照着使用，以根据条件允许这些IA-64指令的执行。Alpha 21264没有等效寄存器。

将两个IA-64转移寄存器指定为便笺式或临时寄存器b4-b5。转移寄存器用于保存转移指令的目的地地址。Alpha 21264使用通用寄存器来实现这一功能。

二进制代码转换器系统的类图

附图7和8表示二进制代码转换器的UML类图。其中包括了主要的功能组件，这些功能部件还带有简要说明。附图7是按照二进制代码转换器的功能单元的顺序组织起来的并且重点强调了主系统。这里并没有表示出所有的类。虽然并不能从这个图表中明显地看出，但是一组C++基本类组成了本二进制代码转换器的基础。该组类并不专门适合于任何具体的遗留处理器或主处理器。其中的另一层用于整合本机处理器的专有信息和遗留处理器的专有信息。

附图8是以等级体系的方式组织的并且表示出了所有类自顶向下的体系结构。其中并没有示出本二进制代码转换器的所有类。

代码转换过程示意图

附图9表示代码转换过程示意图。二进制代码转换器会话管理程序对象62位于代码转换过程的顶级。它依次对遗留处理程序子系统36和本机处理程序子系统40进行调用。该图中示出了六个总体步骤：

1.载入程序子系统34用于载入遗留程序。将遗留数据段无修改地提交给存储器。遗留指令传给该系统的用于代码转换的其余部分。

2.然后确定遗留指令的类型并且将这些遗留指令组合为以流程控制指令结束的遗留指令组。本步骤的输出是一系列的LegacyProcedure对象，它们的每一个都含有LegacyInstruction对象的总量。这些对象的集合是遗留程序的指令部分。

3.如果存在转换前优化模块64并且该模块是有效的，则对其进行调用。这些模块对步骤2中生成的LegacyProcedure和LegacyInstruction对象进行操作。

4.将LegacyInstruction转换为本机处理器指令。本步骤的输出是NativeInstruction对象，将这些对象添加到各个LegacyProcedure对象中。所有本机指令对象的集合是经转换程序的指令部分。

5.如果存在转换后优化模块66并且该模块是有效的，则对其进行调用。这些模块可能会利用LegacyProcedure和/或LegacyInstruction对象对步骤4中生成的NativeInstruction对象进行操作。

6.最后一个步骤是将经转换的程序提交给本机处理器存储器以准备执行或交付给一个由标有“输出程序”的块68表示的磁盘文件以便今后使用。

指令转换实例

下面将给出用于将几个具有代表性的Alpha 21264指令转换为IA-64指令的代码的实例。Alpha标准型使用这样一种指令转换结构方式，该结构方式为每个遗留Alpha指令提供一个称为遗留指令转换器的C函数并且为每个IA-64指令提供一个称为本机指令发生器的C函数。之所以使用C函数是因为它们的地址能够保存在一个表中以便有效访问。所述指令转换器对遗留指令进行检查、提取操作代码并弹出用于该条Alpha指令的遗留指令转换器函数的地址。该遗留指令转换器函数根据需要反过来使用本机指令发生器来产生IA-64指令。下面将对两个Alpha指令的例子进行探讨。

ALPHA S4ADDQ，文字形式

这条指令是一条用于将一个文字值加到一个已经存在于寄存器中的值上的整型加法指令。下面给出的第一个例子表示用于这条Alpha指令的遗留指令转换器。该函数调用两个不同的IA-64指令发生器函数shladd和add_i14。这些C函数产生复制Alpha S4ADDQ指令的行为所需的IA-64二进制指令。在调用了每个IA-64指令发生器函数之后，这些IA-64指令就被添加到转换器子系统中以等候将其提交给本机处理器存储器和/或磁盘文件之前的进一步处理。

遗留指令转换器函数被Alpha到IA-64转换器用于将Alpha 21264指令转换为IA-64等价指令。在这种情况下，需要两个IA-64指令。对于其它的遗留指令来说，将会需要更多或更少的指令。下面的第二个例子表示产生IA-64‘shladd’指令所需要的IA-64指令发生器函数。

    /*

     *This function translates the Alpha instruction Scaled Add Quadword by 4.

     *S4ADDQ multiplies Ra by 4 and adds it to lit.The 64-bit sum is stored in Rc

     */

    INT64 S4ADDQ_LIT(Translator *translator，UINT64 Ra，UINT64 1it，UINT64 Rc)

    {

       NativeInstruction instr；

       //Get the necessary temp registers

       UINT64 rTemp1＝translator-＞regMaps-＞getGPTempReg ()；

       //Get the mapped IA64 registers for the input Alpha registers

       Ra＝translator-＞regMaps-＞getMappedIA64GenReg  (Ra)；

       Rc＝translator-＞regMaps->getMappedIA64GenReg  (Rc)；

       //Writes to the zero reg produce faults in IA64 but not in Alpha

       if(Rc!＝GPRegZero)

       {

         //rTemp1＝Ra * 4

         shladd(translator，&amp;instr，PredRegZero，rTemp1，Ra，2，GPRegZero)；

         translator-＞addNativeInstruction(&amp;instr)；

         //Rc＝rTemp1+1it

         adds_i14(translator，&amp;instr，PredRegZero，Rc，1it，rTemp1)；

         translator-＞addNativeInstruction(&amp;instr)；

       }

       return 0 ；

    }

Alpha S4ADDQ文字形式指令转换器函数

    //******************************************************************************

    //******************************************************************************

    // This function generates type A2 instructions.

    void genA2(Translator *translator，NativeInstruction *inst，UINT64 x4，UINT64 qp，

       UINT64 r1，UINT64 r2，UINT64 ct2，UINT64 r3)

    {

       inst-＞instr       ＝(8UL＜＜37)|(x4＜＜29)|(ct2＜＜27)|qp|(r1＜<6)|

                           (r2＜＜13)|(r3＜＜20)；

       inst-＞type        ＝ALU；

       translator-＞regMaps-＞getGenRegMask(inst-＞srcRegsUsed，r2，r3)；

       inst-＞srcRegType  ＝General；

       translator-＞regMaps-＞getGenRegMask(inst-＞destRegUsed，r1)；

       inst-＞destRegType ＝General；

       inst-＞predReg     ＝translator-＞regMaps-＞getPredRegMask(qp)；

    }

    void shladd(Translator *translator，NativeInstruction *inst，UINT64 qp，UINT64 r1，

       UINT64 r2，UINT64 count，UINT64 r3)

    {

       //IA64 needs count to be 1 less than actual number of bits to be shifted

       count--；

       genA2(translator，inst，4，qp，r1，r2，count，r3)；

    }

用于‘shladd’指令的IA-64指令发生器函数

还需要注意的是：寄存器重映射函数也是由遗留指令转换器进行处理的。另一个需要重点注意的问题是，在IA-64上执行这个Alpha指令需要一个单临时寄存器。

ALPHA CMOVEQ

Alpha CMOVEQ指令根据条件将一个值移送到一个Alpha通用寄存器中。用于这个指令的遗留指令转换器可以在下面的例子中找到。这个Alpha指令再一次需要两个IA-64指令，cmp.eq(8位直接形式)和add(寄存器形式)。

 /*
 *This function translates the Alpha instruction Conditional Move if Register
 *Equal to Zero，If register Ra is equal to 0，Rb is written to Rc.
 */
INT64 CMOVEQ(Translator *translator，UINT64 Ra，UINT64 Rb，UINT64 Rc)
{
   NativeInstruction instr；
   //Get the necessary temp registers
   UINT64 pTemp1＝translator-＞regMaps-＞getPredTempReg  ()；
   UINT64 pTemp2＝translator-＞regMaps-＞getPredTempReg  ()；
   //Get the mapped IA64 registers for the input Alpha registers   Ra＝translator-＞regMaps-＞getMappedIA64GenReg  (Ra)；
   Rb＝translator-＞regMaps-＞getMappedIA64GenReg  (Rb)；
   Rc＝translator-＞regMaps-＞getMappedIA64GenReg  (Rc)；
   //Writes to the zero reg produce faults in IA64 but not in Alpha
   if(Rc！＝GPRegZero )
   (

     //Determine if Ra is equal to zero    

     cmp_eq_i8(translator，&amp;instr，PredRegZero，pTemp1，pTemp2，0，Ra)；

     translator-＞addNativeInstruction(&amp;instr)；

     //conditionally do the move

     add_r(translator，&amp;instr，pTemp1，Rc，GPRegZero，Rb)；

     translator-＞addNativeInstruction(&amp;instr)；
   }
   return 0；
}

Alpha CMOVEQ遗留指令转换器函数

优化程序实例-IA-64代码调度程序优化程序

下面的优化程序实例通过尝试对经转换的指令进行最佳调度利用IA-64 EPIC体系结构来实现指令并行度的最大化。Itanium 2处理器每时钟周期能够执行多达6条指令。必须将这些指令组成为具有3个41位指令以及一个5位template域的指令束，其中所述5位template域代表执行这些指令需要那些处理器资源。该优化程序对本机指令进行分析，以根据数据相关性判定哪些指令可以安全地并行执行，然后选择指令束来匹配那些指令组。在附图10中示出了这一总体过程。按照本发明的二进制代码转换器将遗留程序分解为多个遗留指令组70。IA-64调度优化程序然后将经转换的本机等价指令分解为IA-64指令组72、74、76。一个IA-64指令组中的所有指令能够同时得以执行，因此，在它们彼此之间不包含数据相关性。该优化程序然后将IA-64指令组72、74、76分解为各自具有3条指令的IA-64指令束78、80、82、84、86和88。

这一调度算法仅应用于Itanium 2和较新的IA-64处理器。不过，各种本机处理器都可以合理地受益于适用于它们的体系结构的简明指令调度算法。

IA-64体系结构限定了有限数量的束类型。在同一个束中并不是所有的IA-64指令的组合都是合法的。例如，一种标识为MMI的常用束类型，这代表在该束中含有两个存储器指令和一个整型指令。这些束的类型被编码在这些束的5位template域中。谨慎选取束类型对避免处理器停顿来说是很重要的。最终，IA-64调度程序优化程序使用一种谨慎设计的算法来为一个指令组中的IA-64指令选择束类型。附图11中示出了一种示范性的算法。

转换过程实例

下面的例子是一个针对Alpha遗留处理器和一个IA-64本机处理器的例子。将一组四个遗留Alpha指令转换为IA-64指令并且为这个本机处理器对这些指令进行适当的组织。

附图12表示一小块Alpha指令以及将它们转换为IA-64指令的过程的图解说明。这个附图只表示了代码转换步骤，而并没有优化处理。遗留代码块总是以某种类型的流程控制指令结束，通常是跳转指令或转移指令，并且将这些遗留代码块称为遗留进程(虽然从初始源代码的观点来说它们可能并不真正代表一个完整的遗留进程)。遗留进程中的所有指令是顺序地执行的。这个例子假设已将遗留程序分解为各个遗留进程并且单个进程的代码转换正在进行。

代码转换过程包括：获取单条遗留指令、根据操作码(opcode)利用一个查找表格对其进行解码以及调用适当的遗留指令代码转换器函数，然后其按照需要构造本机处理器指令。这一过程一般包括下述步骤：

1.可能需要一个或多个暂时(临时)寄存器。如果是这种情况，它们是从负责寄存器映射的X-port对象中申请的。对于IA-64本机处理器来说，是将IA-64的128个通用寄存器的一部分贡献出来用作暂时寄存器的。

2.将遗留指令所使用的所有的遗留寄存器均映射为它们相应的主处理器寄存器。再一次，还是由X-port的寄存器映射组件来进行这一服务。

3.既然已经对寄存器进行了映射并且对暂时寄存器进行了指定，那么如果需要，遗留代码变换器函数调用本机指令发生器函数来以自然二进制形式产生主处理器指令。就这个例子来说，需要七个不同的IA-64指令(sxt4使用了三次)，并且，从而，使用了七个不同的本机指令发生器函数。

这一过程的输出是一组连续时序本机处理器指令，它们最终执行与遗留指令相同的功能。在附图12中，对每个所得到的IA-64主处理器指令进行了编号，以供进一步引用。如图中所看到的，对于所示的哪个Alpha指令，需要九个IA-64指令来进行正确的仿真。这一数量可多可少，这取决于遗留指令的混合程度。

该组指令可就此打成一个程序包并照现在这样执行，不过这可能会导致IA-64主处理器的较差的性能。下述内容简要介绍了为了提高性能应当如何对这些指令进行封包处理。虽然这一信息是IS-64专用的，但是其它的主处理器也能够进行并且需要类似的代码重组来实现最高性能。

IA-64体系结构需要将这些指令组合为指令束。指令束的编排方式见附图13。每个束由三个IA-64指令组成，每个指令的长度是41位。每个束还含有一个5位template域，它用于说明这一组三个指令所需要的处理器资源。这些资源是处理器执行单元。

附图14表示一个Itanium 2处理器中能够使用的执行单元。这些执行单元包括四个储存器单元(它们还能够执行许多简单的整型和逻辑指令)、两个整型单元、两个浮点单元(它们还能够执行长指令或扩展指令)以及三个转移单元。该附图还示出了这些单元是如何由一组两个指令束使用的。这将在下面做进一步介绍。需要注意的是，如果有足够的处理器资源可以使用，IA-64处理器每次能够执行两个完整的指令束(六条指令)。

束中的template域指明了该束中的指令需要哪些执行单元的组合。例如，template域值16代表代码MIB，它意谓着需要使用一个存储器单元、一个整型单元和一个转移单元。Template域还可以规定一个stop条件，它意谓着所有当前执行的指令都必须在处理器接收到任何新的指令之前完成。Stop用于防止数据相关性的扰乱。Template 17也是一个MIB类型，只是在束的终端规定了一个stop。它由符号MIB表示。

术语IA-64指令组涉及全部都符合并行执行的条件的一组IA-64指令。IA-64指令组最终都要组成为一个或多个末尾处必须含有一个stop的指令束。

使用关于IA-64主体系结构的这一信息，可以对代码转换过程的下一步骤进行检验。附图15表示用于IA-64主处理器的下一步骤。

附图15表示从附图12得到的彼此之间不含数据相关性的一组指令。这是一个单一的IA-64指令组。

IA-64主处理器具有良好性能的必要条件是，以不允许数据相关性扰乱的顺序对指令进行适当的调度以最大化并行度。因此，IA-64的X-port的专用部分进行对附图12中所发出的指令流的分析，并且判断哪些指令可以安全地同时执行。在附图15中，可以看到指令1、2、5、6和8彼此之间不具有寄存器相关性，并因此，它们能够安全地并行执行。不过，这是五条指令的一个序列。必须对IA-64指令束进行选定以含有这些指令。然后将所得到的指令束提交给存储器作为可执行IA-64代码的一部分。需要注意的是，IA-64 movl指令需要两个束位置。

附图16表示第二个IA-64指令组，它仅含有三条指令(3、7和9)。这个IA-64指令组适合于一个的MIB型单束。虽然在本例中没有出现，但是有可能出现没有将指令束全部填满的情况。在这些情况中，可以将不操作代码插入到任意束位置中以使束完整。IA-64指令束的构成代表这一过程的结束。一旦构成了这种形式，IA-64指令就可由主处理器直接执行了。

转换后优化实例

下述内容是一个可以在代码转换发生之后进行调用的优化程序的实例。该实例采用了一个Alpha遗留处理器和一个IA-64本机处理器。其目的是使用IA-64主处理器的称为判断的功能来消除短正向转移。判断允许根据条件指向一条或多条指令。

下面的例子表示一个简单的C语言if-then结构，用于说明使用IA-64判断功能的原因。(假设寄存器r5为a，r6为b，而r7为c。)如所看到的，如果a大于b，则变量c将会具有值0。否则，c将等于1。这种语句可以用图中所示的汇编语言表示。

                          if  (a>b)

                          {

                               c＝0；

                          }

                          else

                          {

                               c＝1；

                          }

    //PowerPC implementation--a conditional branch and an unconditional

    //branch are required

                cmpgt    r5，r6              // compare′a′and′b′

                beq      a_gt_b              //jump if true

                li       r7，1               //c＝1(false case)

                b        done

    a_gt_b：    li       r7，0               //c＝0(true case)

    done：                                   //continue executing here

    //IA-64 implementation--no branches required

         cmp.gt      p1，p2＝r5，r6          //compare′a′and′b′

    (p1) mov         r7＝o                   //if a＞b，c＝o

    (p2) mov         r7＝1                   //else，c＝1

用汇编语言的等价语句简化C语言的if-then语句

绝大部分的现代微处理器体系结构需要使用一个或多个转移指令来根据条件为c赋值。然而IA-64执行时不需要，其原因就是判断功能。IA-64 cmp.gt指令对r5和r6进行比较并将一个true或false(1或0)值保存到判定寄存器p1和p2中。这两个寄存器中的结果被用于根据条件执行下两条指令。第一个mov只有当p1＝1时执行。第二个mov只有当p2＝1时执行。由于所给出的比较指令的比较的ture或flase结果返回到p1中并且将该结果的求反值返回到p2中，因此只有一条mov指令是有效的。而另一条指令将不会执行。

这一概念可以用于消除短正向条件转移。附图17表示一小段含有一个短正向条件转移指令(BEQ)的Alpha代码。如果该转移出现在地址100C，则1010和1014处的指令将不执行。如果转移条件没有得到满足，则该转移失败并且前面说的那两条指令将会执行。

如该图所显示的，BEQ指令可以由一个IA-64比较指令代替，该比较指令将其结果保存到IA-64判定寄存器中。然后可以利用这些判定寄存器根据条件执行对应于Alpha ORNOT和ADDQ指令的IA-64等价代码，从而消除了一个不必要的条件转移。这是非常有益处的，因为现代微处理器是沿着它们确信正确的指令路径尝试预取指令的。如果处理器错误地判定了条件转移发生与否，将会造成性能恶化，这是因为必须对已经存在于处理器的(多个)管道中的误判指令进行刷新，并且必须沿着备用通路提取指令来执行。出于这些原因，只要有可能，对条件转移的消除通常是合乎需要的。

这个优化程序实例是一个能够利用本机处理器中有而遗留处理器中没有的功能的例子。

该优化模块对经代码转换的遗留代码(所得到的IA-64代码)进行搜索来查找短正向条件转移。当其发现了这些条件转移时，它就消除这些转移，产生用于比较的IA-64二进制代码，并修改将要进行判定的指令。这一过程是在代码转换完成之后且在将本机指令提交给存储器以备执行之前发生的。因此，还是有可能改变它们的行为的。

转换前优化实例

下面是转换前优化的一个例子。它允许内嵌地执行函数。内嵌是一种编译器技术，它以“联机”的方式展开函数的内容，而不是设置为跳转到函数本身。适于内嵌的函数通常是短小并且不经常调用其它函数的函数。函数内嵌的缺点是无论在哪里调用函数，都要对该函数的代码进行复制。这增加了程序对存储器的需求量。不过，现代本机处理器，例如IA-64，可能含有数十亿字节的随机存取存储器。对于这种处理器来说，根本察觉不到函数内嵌对存储器造成的影响。

下面的例子表示一个小的C语言代码实例。这里，funcX调用funcY，funcY执行一个非常简单的操作。优化编译器可以根据编程器所选定的最佳条件选择决定内嵌funcY。

                  int funcX(int a)

                  {

                        funcY(a)；    //call funcY

                  }

                  int funcY(int b)

                  {     ：

                       return b+7；

                  }
   　　　　　　　 调用一个小的C函数的C函数

另一方面，按照本发明的二进制代码转换器能够在更广泛范围内选择用于为了速度而牺牲存储器使用率的内嵌的指令。对于每个内嵌的函数来说，可以省略遗留代码的下述部分：

1.初始化代码：通常为了执行函数调用需要有一定数量的初始化。

该数量很可能是在多达六条遗留指令的范围之内，不过在平台与平台之间可能是不同的。

2.无条件转移：一种‘跳转’指令，将代码执行引导到所正在被调用的函数。

3.函数引导程序：通常，函数包含某种类型的引导程序，通常由几个指令组成。引导程序中所执行的操作包括为数据区建立全局指针。

4.函数调用返回：从函数返回通常包括一些清除指令。

5.无条件转移：一种‘返回’指令，将代码执行引导到进行调用的函数。

在许多情况下，由于能够消除大量的遗留代码，内嵌函数能够实现性能的提高。

这个优化程序是在遗留代码得以转换之前但是在已经对遗留代码进行组合之后对遗留代码产生作用的。它搜索函数调用，并且当其发现一个合法的内嵌函数时，就为该二进制代码转换系统插入提示。

除了具有充足的存储器使内嵌比起最初的遗留系统来讲更加可行之外，这种优化方法并不是专门针对IA-64主处理器的性能而设计的。

显然，根据上述的教导，本发明的许多修改和改变都是可能实现的。因此，应当明白，在所附的权利要求书的范围之内，除了上面所具体说明的方式之外，还可以以其它的方式实现本发明。

Claims

1.一种二进制代码转换器，包括：

一个载入程序子系统，用于读取遗留二进制指令并将其载入到一个文件当中；和

一个代码转换器，用于直接将所述遗留二进制指令转换为本机二进制指令，所述代码转换器对于使用不同的遗留处理器和本机处理器的应用来说是可重新配置的。