CN114830097A - 处理器、模拟器程序、汇编程序以及信息处理程序 - Google Patents

Abstract

处理器具有：第一寄存器；第二寄存器，储存与上述第一寄存器相关的状态信息；以及检测电路，基于储存于上述第二寄存器的上述状态信息，检测上述第一寄存器被指定为操作数的命令中的异常。

Description

处理器、模拟器程序、汇编程序以及信息处理程序

技术领域

本发明涉及处理器、模拟器程序、汇编程序以及信息处理程序。

背景技术

有在编译器根据源程序生成的汇编语言的代码中包含有不对程序的执行结果给予影响的不必要的命令的情况。这样的命令使程序的执行速度降低，成为阻碍使处理器的性能发挥到极限的重要因素。另外，由于编译器的优化功能有极限，所以有编译记述了复杂的处理的源程序而得到的可执行程序与手动地进行了优化的汇编语言的代码相比执行速度慢的情况。

因此，在要求程序的执行速度的高速化的HPC(High Performance Computing：高性能计算)等领域，有开发者手动地记述适合该程序的汇编语言的代码的情况。

但是，与C语言、C++等高级语言相比，汇编语言的抽象度较低，所以容易产生记述错误，并且难以发现在程序的何处有记述错误。

专利文献1：日本特开平5-143338号公报

发明内容

根据一侧面，目的在于检测起因于程序的记述错误的异常。

根据一侧面，提供处理器，其具有：第一寄存器；第二寄存器，储存与上述第一寄存器相关的状态信息；以及检测电路，基于储存于上述第二寄存器的上述状态信息，检测上述第一寄存器被指定为操作数的命令中的异常。

根据一侧面，能够检测起因于程序的记述错误的异常。

附图说明

图1的(a)是设置于处理器的通用寄存器的示意图，图1的(b)是设置于处理器的向量寄存器的示意图。

图2是表示指定128位长的向量寄存器的汇编语言的格式的示意图。

图3的(a)、(b)是表示使用了向量寄存器的汇编语言的语法的示意图(其一)。

图4的(a)、(b)是表示使用了向量寄存器的汇编语言的语法的示意图(其二)。

图5是表示使用了向量寄存器的汇编语言的语法的示意图(其三)。

图6的(a)、(b)是表示使用了通用寄存器的汇编语言的语法的示意图。

图7是表示开发者记述的汇编语言的源代码的正确的编码例的示意图。

图8是表示用于说明第一例的记述错误的汇编语言的源代码的示意图。

图9是表示用于对将向量寄存器指定为操作数时的第一例的记述错误的例子进行说明的汇编语言的源代码的示意图。

图10是表示用于说明第二例的错误的汇编语言的源代码的示意图。

图11是表示用于说明第三例的错误的汇编语言的源代码的示意图。

图12是表示用于说明第四例的记述错误的汇编语言的源代码的示意图。

图13是表示用于说明第五例的记述错误的汇编语言的源代码的示意图。

图14是总结第一例～第五例的记述错误的图。

图15是第一实施方式的处理器的构成图。

图16是第一实施方式的状态寄存器文件和运算用寄存器文件各自的示意图。

图17是示意性地表示第一实施方式的第二异常检测部检测异常时的检测规则的图。

图18是第一实施方式的第二异常检测部的框图。

图19是用于说明第一实施方式的异常处理电路的功能的示意图。

图20是示意性地表示第一实施方式的storeStatus命令和loadStatus命令的图。

图21是示意性地表示第一实施方式的saveStatus命令和loadStatus命令的图(其一)。

图22是示意性地表示第一实施方式的saveStatus命令和loadStatus命令的图(其二)。

图23的(a)是抑制第一实施方式的异常检测电路的功能时的汇编语言的源代码的示意图，图23的(b)是在第一实施方式的disableExeptGen命令中记述了操作数的例子的示意图，图23的(c)是在第一实施方式的enableExeptGen命令中记述了操作数的例子的示意图。

图24是执行第二实施方式的模拟程序的信息处理装置的硬件构成图。

图25是第二实施方式的信息处理装置执行模拟程序时的信息处理装置的功能构成图。

图26是第二实施方式的环境构建部生成的伪处理器的功能框图。

图27是表示第一实施方式的处理器的各部与第二实施方式的伪处理器的各部之间的对应关系的图。

图28是用于说明第二实施方式的模拟方法的流程图。

图29是第二实施方式的异常检测处理的流程图。

图30是在第三实施方式中执行可执行程序的目标机具备的处理器的构成图。

图31是执行第三实施方式的汇编程序的信息处理装置的硬件构成图。

图32是第三实施方式的信息处理装置执行汇编程序时的信息处理装置的功能构成图。

图33是表示第三实施方式的状态信息的C++的源代码的示意图。

图34的(a)是示意性地表示通用寄存器被指定为操作数的情况下的第三实施方式的检测规则的图，图34的(b)是示意性地表示向量寄存器被指定为操作数的情况下的第三实施方式的检测规则的图。

图35是抑制第三实施方式的异常检测部的功能时的汇编语言的源程序的示意图。

图36是表示第三实施方式的命令行自变量的一个例子的示意图。

图37是第三实施方式的汇编程序执行的处理的流程图。

图38是第三实施方式的异常检测处理的流程图。

图39是执行通过AOT(Ahead Of Time：提前)编译技术、JIT(Just In Time：即时)编译技术生成的可执行程序的第四实施方式的信息处理装置的硬件构成图。

图40的(a)是表示以利用AOT编译技术进行编译为前提的C++的伪源代码的一个例子的示意图，图40的(b)是表示声明了参数“q”和数组“in”、“out”的C++的伪源代码的一个例子的示意图，图40的(c)是表示声明了数组“Tbl”的初始值的C++的伪源代码的一个例子的示意图。

图41是利用AOT编译技术进行编译而得到的汇编程序的伪代码的示意图。

图42是表示利用AOT编译技术得到的可执行程序的动作的示意图。

图43是表示使用了JIT编译技术的C++的伪源代码的一个例子的示意图。

图44是表示在编译使用了JIT编译技术的源代码而得到的可执行程序的执行中，在存储器写入何种机器语言的命令列的示意图。

图45是表示利用JIT编译技术在执行时生成在执行时调用的函数的可执行程序的动作的示意图。

图46是用于说明第一例的记述错误的应用程序用的C++的源代码的示意图。

图47是用于说明第二例的记述错误的应用程序用的C++的源代码的示意图。

图48是用于说明第三例和第四例的记述错误的应用程序用的C++的源代码的示意图。

图49是用于说明第五例的记述错误的应用程序用的C++的源代码的示意图。

图50是总结第一例～第五例的记述错误的图。

图51是表示第四实施方式的状态信息的C++的伪源代码的示意图。

图52的(a)是示意性地表示通用寄存器被指定为助记函数的自变量的情况下的第四实施方式的检测规则的图，图52的(b)是示意性地表示向量寄存器被指定为助记函数的自变量的情况下的第四实施方式的检测规则的图。

图53的(a)～(d)是定义第四实施方式的助记函数所使用的各种类型的C++的伪源代码的示意图(其一)。

图54的(a)～(d)是定义第四实施方式的助记函数所使用的各种类型的C++的伪源代码的示意图(其二)。

图55是记述了定义第四实施方式的助记函数multiply的C++的源代码的源文件的示意图(其一)。

图56是记述了定义第四实施方式的助记函数multiply的C++的源代码的源文件的示意图(其二)。

图57是记述了定义第四实施方式的助记函数float_multiply的C++的源代码的源文件的示意图(其一)。

图58是记述了定义第四实施方式的助记函数float_multiply的C++的源代码的源文件的示意图(其二)。

图59是在第四实施方式中，记述了定义读入8位的数据的助记函数vload的C++的源代码的源文件的示意图。

图60是在第四实施方式中，记述了定义读入16位的数据的助记函数vload的C++的源代码的源文件的示意图。

图61是在第四实施方式中，记述了定义对8位的数据进行加法运算的助记函数vadd的C++的源代码的源文件的示意图。

图62是在第四实施方式中，记述了定义对16位的数据进行加法运算的助记函数vadd的C++的源代码的源文件的示意图。

图63是在第四实施方式中，记述了定义将8位的数据保存于存储器的助记函数vstore的C++的源代码的源文件的示意图。

图64是在第四实施方式中，记述了定义将32位的数据保存于存储器的助记函数vstore的C++的源代码的源文件的示意图。

图65是记述了定义第四实施方式的助记函数cvtssBtoH的C++的源代码的源文件的示意图。

图66是在第四实施方式中，记述了定义读入有符号整数立即值的助记函数vmov的C++的源代码的源文件的示意图。

图67是在第四实施方式中，记述了定义读入无符号整数立即值的助记函数vmov的C++的源代码的源文件的示意图。

图68是在第四实施方式中，记述了定义读入32位的浮点小数立即值的助记函数vmov的C++的源代码的源文件的示意图。

图69是记述了定义第四实施方式的助记函数cvtFloatSigned的C++的源代码的源文件的示意图。

图70的(a)、(b)是示意性地表示在第四实施方式中抑制检测异常的功能的方法的图。

图71是能够在第四实施方式中抑制检测异常的功能的助记函数的C++的伪源代码的示意图。

图72的(a)是在第四实施方式中，在助记函数xor的内部记述了用于抑制检测异常的功能的全局变量时的源文件的示意图，图72的(b)是示意性地表示利用了该助记函数xor的应用程序用的源文件的C++的伪源代码的图。

图73是表示在第四实施方式中，记述了MachineCodeEmitter函数的C++的伪源代码的源文件的一个例子的示意图。

图74是表示在第四实施方式中，利用定义了助记函数的源文件的开发环境的示意图。

图75是在第四实施方式中，在用于得到可执行程序的应用程序用的源文件中记述的C++的伪源代码的示意图。

图76是表示在第四实施方式中，执行可执行程序时的信息处理装置的动作的流程图。

图77是进行助记函数的执行处理时的第四实施方式的信息处理装置的功能构成图。

图78是第四实施方式的信息处理方法的流程图。

图79是第四实施方式的异常检测处理的流程图。

具体实施方式

如上述那样，与C语言等高级语言相比，汇编语言的编码容易产生记述错误。虽然在编码时的各种情况下可能产生记述错误，但特别是在指定寄存器作为命令的操作数时容易犯错误。因此，首先对设置于处理器的寄存器进行说明。

图1的(a)是设置于处理器的通用寄存器xn(n＝0、1、2、…、31)的示意图。

通用寄存器xn(n＝0、1、2、…、31)是不限定于特定的用途的寄存器，例如是储存数据、地址以及立即值等的寄存器。这里，根据索引n(＝0、1、2、…、31)识别多个通用寄存器xn的各个。

另一方面，图1的(b)是设置于处理器的向量寄存器vn(n＝0、1、2、…、31)的示意图。

向量寄存器vn(n＝0、1、2、…、31)是SIMD(Single Instruction Multiple Data：单指令多数据)寄存器，是用于储存成为向量运算的对象的向量数据的寄存器。与通用寄存器xn(n＝0、1、2、…、31)相同，在本实施方式中，根据索引n(＝0、1、2、…、31)识别多个向量寄存器vn(n＝0、1、2、…、31)的各个。另外，各个向量寄存器vn(n＝0、1、2、…、31)的大小例如为128位。

图2是表示在基于作为能够指定向量寄存器的指令集的ARM公司的ARMv8-A架构的处理器中，指定128位长的向量寄存器vn(n＝0、1、2、…、31)的汇编语言的格式的示意图。

如图2所示，关于在汇编语言中指定向量寄存器vn(n＝0、1、2、…31)，采用“vn.x”、“vn.d”、“vn.s”、“vn.h”、“vn.b”这样的格式。

在该格式中，“vn”是指定索引为“n”的向量寄存器vn的格式。而且，接着点“.”之后的“x”、“d”、“s”、“h”、“b”是表示储存在一个向量寄存器vn的向量数据的元素的大小的格式。例如，“x”表示元素的大小为128位，“d”表示元素的大小为双字(64位)。

同样地，“s”、“h”、“b”表示元素的大小分别为单字(32位)、半字(16位)、字节(8位)。

这样，在该格式中，通过以点“.”连结“vn”与“d”的“vn.d”等字符串，指定向量寄存器vn和其元素的大小。

接下来，对使用了向量寄存器的汇编语言的语法进行说明。

图3～图5是表示使用了向量寄存器的汇编语言的语法的示意图。

其中，图3的(a)是表示vadd命令的语法的示意图。图3的(a)的vadd命令是将两个向量寄存器v0、v1的分别对应的元素彼此相加，并将其结果储存于向量寄存器v2的对应的元素的有符号整数的加法命令。这样，vadd命令是各向量寄存器的各元素的加法命令，所以以各向量寄存器v0、v1、v2各自的元素的大小相同为前提。

因此，开发者使vadd命令的操作数中的全部的向量寄存器的元素的大小例如为相同的“b”。该情况下，vadd命令成为将储存于各向量寄存器的元素的8位的有符号整数相加的命令。

图3的(b)是表示vadd命令的语法的其它的例子的示意图。

在图3的(b)的例子中，使被指定为vadd命令的操作数的各向量寄存器的元素的大小为“h”。该情况下，vadd命令成为将储存于各向量寄存器的元素的16位的有符号整数相加的命令。

图4的(a)是表示vfadd命令的语法的示意图。

图4的(a)的vfadd命令是将两个向量寄存器v0、v1的分别对应的元素彼此相加，并将其结果储存于向量寄存器v2的对应的元素的浮点小数的加法命令。与上述的vadd命令相同，vfadd命令也是各向量寄存器的各元素的加法命令，所以是以各向量寄存器v0、v1、v2各自的元素的大小相同为前提的命令。

由此，开发者使vfadd命令的操作数中的全部的向量寄存器的元素的大小例如为相同的“s”。该情况下，vfadd命令成为将储存于各向量寄存器的元素的32位的浮点小数相加的命令。

图4的(b)是表示vfadd命令的语法的其它的例子的示意图。

在图4的(b)的例子中，使被指定为vfadd命令的操作数的各向量寄存器的元素的大小为“d”。该情况下，vfadd命令成为将储存于各向量寄存器的元素的64位的浮点小数相加的命令。

图5是表示multiply命令的语法的示意图。

图5的multiply命令是将两个向量寄存器v0、v1的分别对应的元素彼此相乘，并将其结果储存于向量寄存器v2的各个元素的整数的乘法命令。multiply命令像这样是各元素的乘法命令，所以是以各向量寄存器v0、v1、v2各自的元素的大小相同为前提的命令。在该例子中，使各向量寄存器v0、v1、v2各自的元素的大小为相同的“h”。

并且，multiply命令不支持如整数和浮点那样数据类型不同的数据彼此的积。因此，multiply命令是以分别在源寄存器的向量寄存器v0、v1写入相同的数据类型的数据为前提的命令。

接下来，对使用了通用寄存器的汇编语言的语法进行说明。

图6的(a)、(b)是表示使用了通用寄存器的汇编语言的语法的示意图。

其中，图6的(a)是表示add命令的语法的示意图。add命令是以通用寄存器为对象的有符号64位整数的加法命令。在图6的(a)的例子中，将分别储存于两个通用寄存器x0、x1的数据相加，并将其结果写入到通用寄存器x2。

与向量寄存器不同，在通用寄存器中不考虑元素彼此的运算。因此，在add命令的操作数中，不需要利用点“.”来指定元素的大小。

另外，图6的(b)是表示fadd命令的语法的示意图。

fadd命令是以通用寄存器为对象的64位的浮点小数的加法命令。在图6的(b)的例子中，将分别储存于两个通用寄存器x0、x1的数据相加，并将其结果写入到通用寄存器x2。

与add命令相同，在fadd命令的操作数中，不需要利用点“.”来指定元素的大小。

接下来，对汇编语言的编码例进行说明。

图7是表示开发者记述的汇编语言的源代码的正确的编码例的示意图。

在汇编语言的源代码中，指定通用寄存器xn(n＝0、1、2、…、31)、向量寄存器vn(n＝0、1、2、…、31)、以及地址等立即值作为命令的操作数。

例如，在代码T1中，指定“x0”和“地址1”作为load命令的操作数。该代码T1是从作为立即值而指定的“地址1”的存储器读出64位的数据，并将其写入到通用寄存器x0的代码。

另外，在代码T2中，指定“v2.b”、“v0.b”以及“v1.b”作为vadd命令的操作数。该代码T2是读出储存于向量寄存器v0和向量寄存器v1各自的元素的数据，将它们作为8位的有符号整数相加，并将结果写入到向量寄存器v2的命令。

以下，也将代码T2中的向量寄存器v0、v1那样的数据的读出源的寄存器称为源(src)寄存器。另外，也将代码T1的通用寄存器x0、代码T2的向量寄存器v2那样的数据的写入目的地的寄存器称为目的(dst)寄存器。

接下来，对开发者记述的汇编语言的源代码的记述错误的例子进行说明。作为该记述错误的类型，有以下的第一例～第五例。

·第一例

图8是表示用于说明第一例的记述错误的汇编语言的源代码的示意图。

在图8的例子中，在代码T3中，将有符号64位整数的加法结果写入作为目的寄存器的通用寄存器x2。然后，在代码T4中，将该通用寄存器x2指定为fadd命令的源寄存器。

由于fadd命令设为运算的对象的数据类型为浮点小数，所以在作为fadd命令的源寄存器的通用寄存器x2必须写入浮点小数。但是，在该例子中，在代码T3中在通用寄存器x2写入有符号整数，所以该编码错误。

虽然在代码T3、T4中对操作数指定通用寄存器，但将向量寄存器指定为操作数的情况下也可能产生相同的错误。

图9是表示用于说明将向量寄存器指定为操作数时的第一例的记述错误的例子的汇编语言的源代码的示意图。

在图9的例子中，在代码T5中，将有符号32位整数的加法结果写入作为目的寄存器的向量寄存器v2。然后，在代码T6中，将该向量寄存器v2指定为vfadd命令的源寄存器。

与fadd命令相同，vfadd命令也是将浮点小数彼此相加的命令，所以在作为其源寄存器的向量寄存器v2必须写入浮点小数。但是，在该例子中，在代码T5中在向量寄存器v2写入整数，所以该编码错误。

如图8、图9那样，命令设为运算的对象的数据类型与实际写入到源寄存器的数据的数据类型不一致的编码是错误的。

·第二例

图10是表示用于说明第二例的错误的汇编语言的源代码的示意图。

在图10的例子中，在代码T7的vadd命令中，指定单字“s”作为目的寄存器的数据大小。由此，若执行代码T7的vadd命令，则在向量寄存器v2写入具有数据大小为单字“s”的元素的向量数据。

另一方面，在接下来的代码T8的vadd命令中，指定双字“d”作为源寄存器和目的寄存器各自的数据大小。据此，开发者在代码T8中想要进行数据大小为双字“d”的数据彼此的运算。

但是，通过上述的代码T7在源寄存器的向量寄存器v2写入有数据大小为单字“s”的元素，所以若执行代码T8，则得到与开发者的意图不同的结果。

这样，先行命令的目的寄存器的数据大小与将该目的寄存器作为源寄存器的后续命令的该源寄存器的数据大小不同的记述是错误的。

·第三例

图11是表示用于说明第三例的错误的汇编语言的源代码的示意图。

在图11的例子中，在代码T9的add命令中，将作为源寄存器的通用寄存器x0、x1的数据相加，并将其结果写入到通用寄存器x2。但是，在代码T9之前没有使用通用寄存器x1作为目的寄存器的代码。由此，不明确在通用寄存器x1写入何种数据，该数据不确定。即使在这样的状态下执行代码T9，写入到通用寄存器x2的数据也不确定。

因此，这样将未被用作目的寄存器的寄存器指定为源寄存器是错误的。

·第四例

图12是表示用于说明第四例的记述错误的汇编语言的源代码的示意图。

在图12的例子中，在代码T10的add命令中使用通用寄存器x2作为目的寄存器，从而将使通用寄存器x0、x1各自的数据相加后的值写入到通用寄存器x2。

但是，在代码T10以后的代码中，不使用该通用寄存器x2作为源寄存器，而通过代码T11的add命令，覆盖通用寄存器x2的内容。这样一来，一次也未使用写入到通用寄存器x2的代码T10的执行结果，所以代码T10的存在意义不明确，怀疑代码T10或者代码T11中的寄存器的指定错误。

因此，像这样对于已用作目的寄存器的寄存器，在之后不用作源寄存器，而再次指定为目的寄存器是错误的。

·第五例

图13是表示用于说明第五例的记述错误的汇编语言的源代码的示意图。

在图13的例子中，在代码T12中，在向量寄存器v0写入作为vfadd命令的执行结果的浮点小数。另外，在代码T13中，在向量寄存器v1写入作为vadd命令的执行结果的整数。

然后，在代码T14的multiply命令中，将源寄存器的向量寄存器v0、v1各自的元素的数据彼此相乘，并将其结果写入到目的寄存器的向量寄存器v2。

但是，multiply命令如上述那样是以写入到两个源寄存器的数据的类型相同为前提的命令。在该例子中，写入到向量寄存器v0和向量寄存器v1的数据类型分别为浮点型和整数型而不同，所以若执行该multiply命令，则得到与开发者想要的结果不同的执行结果。

由此，这样在写入到两个源寄存器的数据的数据类型不同的情况下也成为编码的错误。

图14是总结上述的第一例～第五例的记述错误的图。

以下，对能够检测图14的各个记述错误、与其等效的错误的各实施方式进行说明。

(第一实施方式)

在本实施方式中，对能够检测起因于图14的第一例～第五例的记述错误的异常的处理器进行说明。

图15是本实施方式的处理器的构成图。

如图15所示，该处理器20具备命令解码电路21、数据获取电路22、命令执行电路23、回写电路24、异常处理电路25、状态寄存器文件26、以及运算用寄存器文件27。

并且，在处理器20的外部设置有具备命令存储器28a和数据存储器28b的存储器28。其中，命令存储器28a是存储在处理器20执行的机器语言的命令列的存储器。而且，数据存储器28b是存储命令的执行时使用的数据的存储器。

另外，运算用寄存器文件27是具备图1和图2所示的通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)的硬件。

另外，状态寄存器文件26是具备储存了表示通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)各自的状态的状态信息的多个寄存器的硬件。

另一方面，命令执行电路23是执行储存于命令存储器28a的命令的电路，具有执行电路30、状态更新电路31、第一异常检测部32a、以及第二异常检测部32b。

在该处理器20中如以下那样执行命令。

首先，命令解码电路21读出位于命令存储器28a的地址中的、未图示的程序计数器指出的地址的机器语言的命令。

然后，命令解码电路21对该命令进行解码，并将解码内容分别输出到数据获取电路22、命令执行电路23以及回写电路24。作为解码内容，有命令的种类、源寄存器和目的寄存器各自的索引、源寄存器的元素的数据大小、以及源寄存器的数据类型。

例如，考虑对相当于汇编语言的“vfadd v2.s，v0.s，v1.s”的命令进行解码的情况。该情况下，命令解码电路21通过对从命令存储器28a读出的机器语言进行解码，确定命令的种类为“vfadd”。另外，命令解码电路21通过对从命令存储器28a读出的机器语言进行解码，确定vfadd命令的源寄存器为“v0”和“v1”，目的寄存器为“v2”。

并且，基于读出的机器语言的位串，命令解码电路21确定第一个源寄存器“v0”的元素的大小为“s”，并且确定第二个源寄存器“v1”的元素的大小为“s”。

而且，如上述那样，命令的种类“vfadd”为将浮点小数作为对象的运算，所以命令解码电路21基于命令的种类“vfadd”确定源寄存器的数据类型为浮点小数。此外，在命令的种类为“add”的情况下，命令解码电路21确定源寄存器的数据类型为有符号整数。

接下来，数据获取电路22基于解码内容，从运算用寄存器文件27和数据存储器28b的任意一方读出数据，并将其输出给命令执行电路23。

例如，在上述的“vfadd v2.s，v0.s，v1.s”的例子中，分别对第一操作数和第二操作数指定寄存器。由此，在该情况下，数据获取电路22读出位于运算用寄存器文件27的向量寄存器v0和向量寄存器v1各自的数据，并将这些数据输出给命令执行电路23。

此外，在命令解码电路21进行解码的机器语言为“load x0，地址1”的情况下，数据获取电路22读出位于数据存储器28b的地址中的“地址1”的数据。然后，数据获取电路22将读出的数据输出给命令执行电路23。

接着，命令执行电路23的第一异常检测部32a和第二异常检测部32b分别检测是否由于命令的执行而产生异常。

其中，第二异常检测部32b是检测起因于汇编语言的记述错误的异常的电路。在本实施方式中，第二异常检测部32b如后述那样基于储存于状态寄存器文件26的状态信息、和命令解码电路21输出的解码内容检测异常。后述其检测方法、状态信息的详细。

另一方面，第一异常检测部32a是检测与汇编语言的记述错误无关的异常的电路。作为这样的异常，有想要执行未安装命令时的异常、执行了除以零时的异常。

这里，在第一异常检测部32a或者第二异常检测部32b检测到异常的情况下，这些异常检测电路生成异常信号并将其输出到异常处理电路25。异常处理电路25是进行与该异常信号对应的处理的电路。

另一方面，在第一异常检测部32a和第二异常检测部32b的任何一个均未检测到异常的情况下，状态更新电路31更新位于状态寄存器文件26的状态信息。

与此同时，执行电路30执行命令，并将其执行结果输出到回写电路24。此时，执行电路30确定命令解码电路21输出的解码内容所包含的命令的种类，并进行与该命令的种类对应的运算。

例如，在上述的“vfadd v2.s，v0.s，v1.s”的例子中，执行电路30确定命令的种类为“vfadd”。然后，执行电路30将向量寄存器v0与向量寄存器v1各自的数据相加，并将由此得到的值输出到回写电路24。

接着，回写电路24将命令的执行结果回写到运算用寄存器文件27和数据存储器28b的任意一方。回写电路24根据命令解码电路21输出的解码内容所包含的命令的种类判断将执行结果回写到它们中的哪一个。

例如，考虑上述的“vfadd v2.s、v0.s、v1.s”的例子。该例子中的“vfadd”是将执行结果回写到目的寄存器的命令。由此，回写电路24将使向量寄存器v0与向量寄存器v1各自的数据相加后的值回写到运算用寄存器文件27的向量寄存器v2。

此外，在命令解码电路21进行解码的操作码表示store命令的情况下，回写电路24将执行结果回写至数据存储器28b。

通过以上，结束一个命令的执行。

图16是状态寄存器文件26和运算用寄存器文件27各自的示意图。

如图16所示，运算用寄存器文件27是具备通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)的寄存器文件。这些寄存器的大小并不特别限定。在本实施方式中，使通用寄存器xn(n＝0、1、2、…、31)的大小为64位，使向量寄存器vn(n＝0、1、2、…、31)的大小为128位。

另一方面，状态寄存器文件26是具备分别与通用寄存器xn(n＝0、1、2、…、31)建立对应关系的状态寄存器sxn(n＝0、1、2、…、31)的硬件。并且，该状态寄存器文件26也具备分别与向量寄存器vn(n＝0、1、2、…、31)建立对应关系的状态寄存器svn(n＝0、1、2、…、31)。

其中，与通用寄存器xn(n＝0、1、2、…、31)对应的状态寄存器sxn(n＝0、1、2、…、31)是用于储存通用寄存器xn(n＝0、1、2、…、31)的状态信息Q的寄存器。状态信息Q是表示通用寄存器xn(n＝0、1、2、…、31)的状态的信息，具备第一标志W、第二标志R以及类型信息DT。

其中，第一标志W是表示在执行电路30执行命令之前通用寄存器xn(n＝0、1、2、…、31)是否已被用作目的寄存器的1位的数据。例如，考虑通用寄存器x0已被用作目的寄存器的情况。该情况下，储存于状态寄存器sx0的状态信息Q的第一标志W为“1”。另外，在该通用寄存器x0未被用作目的寄存器的情况下，该第一标志W为“0”。

另外，第二标志R是表示在命令执行电路23执行命令之前通用寄存器xn(n＝0、1、2、…、31)是否已被用作源寄存器的1位的数据。例如，在通用寄存器x0已被用作源寄存器的情况下，状态寄存器sx0中的第二标志R为“1”，在未被用作的情况下，第二标志R为“0”。

类型信息DT是表示储存于通用寄存器xn的数据的数据类型的数据。作为该数据类型，有有符号整数、无符号整数、浮点小数、以及不确定四个种类。类型信息DT是唯一地识别这四个种类的数据类型的各个的2位的信息。

另一方面，与向量寄存器vn对应的状态寄存器svn(n＝0、1、2、…、31)是用于储存向量寄存器vn(n＝0、1、2、…、31)的状态信息Q的寄存器。该状态信息Q是表示向量寄存器vn(n＝0、1、2、…、31)的状态的信息，除了上述的第一标志W、第二标志R、以及类型信息DT之外，还具有大小信息DS。

大小信息DS是表示储存于向量寄存器vn(n＝0、1、2、…、31)的向量数据的元素的大小的信息。如参照图2进行说明的那样，作为元素的大小，有“x(128位)”、“d(双字)”、“s(单字)”、“h(半字)”、“b(字节)”、以及不确定六个种类。大小信息DS是用于唯一地识别这五个种类的大小的3位的信息。

在各异常检测部32a、32b均未检测到异常而执行电路30正常地执行了命令时，通过状态更新电路31(参照图15)更新上述的状态信息Q。基于解码内容包含的各寄存器的索引和命令的种类如以下那样进行状态信息Q的更新。

例如，在执行电路30执行了源寄存器被指定为操作数的命令时，状态更新电路31根据解码内容确定该源寄存器的索引。然后，状态更新电路31将状态寄存器sxn、svn(n＝0、1、2、…、31)中的具有确定出的索引的寄存器的第二标志R设置为“1”。

另外，在执行电路30执行了目的寄存器被指定为操作数的命令时，状态更新电路31根据解码内容确定该目的寄存器的索引。然后，状态更新电路31将状态寄存器sxn、svn(n＝0、1、2、…、31)中的具有确定出的索引的寄存器的第一标志W设置为“1”。并且，在该情况下，状态更新电路31使该状态寄存器的第二标志R为“0”。由此，该目的寄存器被设定为从写入数据起还未被用作源寄存器的状态。

另外，在执行电路30执行了目的寄存器被指定为操作数的命令时，状态更新电路31更新该目的寄存器的类型信息DT。例如，考虑执行电路30执行了“add x2，x0，x1”这样的命令的情况。该情况下，状态更新电路31基于解码内容，确定命令的种类为“add”，目的寄存器的索引为“2”。该add命令是有符号64位整数的加法命令，通过命令的执行，在目的寄存器的通用寄存器x2储存有符号整数。由此，该情况下，状态更新电路31将状态信息Q更新为储存于索引为“2”的状态寄存器sx2的类型信息DT表示有符号整数。此外，在对目的寄存器指定向量寄存器vn(n＝0、1、2、…、31)的情况下，状态更新电路31也与此相同地更新状态信息Q。

这样，状态更新电路31在执行电路30执行了在寄存器写入数据的命令时，将与该寄存器对应的类型信息DT更新为类型信息DT表示该命令设为运算的对象的数据的数据类型。

并且，状态更新电路31在执行电路30执行了向量寄存器被指定为操作数作为目的寄存器的命令时，更新该目的寄存器的大小信息DS。例如，考虑执行电路30执行了“vaddv3.s，v0.s，v1.s”这样的命令的情况。该情况下，状态更新电路31基于解码内容，确定目的寄存器的索引和数据大小分别为“3”和单字“s”。然后，状态更新电路31将状态信息Q更新为储存于索引为“3”的状态寄存器sv3的大小信息DS表示单字。

这样，状态更新电路31在执行电路30执行了在向量寄存器写入数据的命令时，将与该寄存器对应的大小信息DS更新为表示写入的数据的数据大小。

接下来，对第二异常检测部32b检测的异常进行说明。

图17是示意性地表示第二异常检测部32b检测异常时的检测规则的图。

作为第二异常检测部32b检测的异常的种类，有“W异常”、“R异常”、“数据类型异常”、“数据大小异常”、以及“src数据类型异常”。

其中，W异常是在命令的源寄存器在过去未被用作目的寄存器的情况下产生的异常，在有图14的第三例的记述错误的情况下产生。

能够利用上述的第一标志W检测W异常。例如，在源寄存器的第一标志W为“0”的情况下，该源寄存器在过去未被用作目的寄存器。由此，第二异常检测部32b在第一标志W为“0”的情况下，检测到产生W异常。

另外，R异常是在后续命令中使用先行命令写入了数据的寄存器作为目的寄存器的情况下，在先行命令和后续命令之间的全部的命令都不使用该寄存器作为源寄存器的情况下的异常。在有图14的第四例的记述错误的情况下产生该R命令。

能够利用上述的第一标志W和第二标志R检测R异常。例如，在命令的目的寄存器在过去在其它的命令中已被用作目的寄存器的情况下，第一标志W为“1”。另外，在该目的寄存器在之后的命令中未用作源寄存器的情况下，第二标志R为“0”。由此，第二异常检测部32b在第一标志W为“1”，并且第二标志R为“0”的情况下，检测到产生R异常。

而且，数据类型异常是在命令设为运算的对象的数据类型与实际写入到源寄存器的数据的数据类型不一致的情况下产生的异常，在有图14的第一例的记述错误的情况下产生。

能够利用上述的类型信息DT检测数据类型异常。例如，在该类型信息DT表示的数据类型与命令设为运算的对象的数据类型不一致的情况下，第二异常检测部32b检测到产生了数据类型异常。

另一方面，数据大小异常是由于图14的第二例的记述错误而产生的异常。在先行命令写入到寄存器的数据的数据大小与在将该寄存器作为源寄存器的后续命令中指定的源寄存器的数据大小不同的情况下产生该数据大小异常。

能够利用上述的大小信息DS检测该数据大小异常。例如，在为某一命令的源寄存器指定的数据大小与该源寄存器所对应的大小信息DS表示的数据大小不一致的情况下，第二异常检测部32b检测到产生了数据大小异常。

而且，src数据类型异常是在有图14的第五例的记述错误的情况下产生的异常。在以两个源寄存器的数据类型相同为前提的命令中，各源寄存器各自的数据类型不一致的情况下产生该src数据类型异常。

也能够利用上述的类型信息DT检测src数据类型异常。例如，第二异常检测部32b在以两个源寄存器的数据类型相同为前提的命令中，各源寄存器的类型信息DT的数据类型彼此不一致的情况下检测到src数据类型异常。

图18是第二异常检测部32b的框图。

如图18所示，第二异常检测部32b具有选择电路40、异常检测电路41、以及异常信号生成电路42。

其中，选择电路40根据命令解码电路21输出的解码内容获取源寄存器和目的寄存器各自的索引。然后，选择电路40选择各通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)中的与获取的索引对应的寄存器。

另一方面，异常检测电路41是检测各种异常的电路。在该例子中，异常检测电路41具有数据类型异常检测电路43、数据大小异常检测电路44、W异常检测电路45、src数据类型异常检测电路46、以及R异常检测电路47。

其中，数据类型异常检测电路43是检测数据类型异常的电路。为了进行数据类型异常的检测，数据类型异常检测电路43根据命令解码电路21输出的解码内容，获取期待储存于源寄存器的数据类型。并且，数据类型异常检测电路43经由选择电路40获取与该源寄存器对应的状态信息Q。

然后，数据类型异常检测电路43判定状态信息Q的类型信息DT表示的数据类型与从命令解码电路21获取的源寄存器的数据类型是否一致。而且，在判定为不一致的情况下，数据类型异常检测电路43向异常信号生成电路42输出检测到数据类型异常这样的检测结果。

另外，数据大小异常检测电路44是检测数据大小异常的电路。为了进行数据大小异常的检测，数据大小异常检测电路44基于命令解码电路21输出的解码内容，获取期待储存于源寄存器的向量数据的元素的数据大小。并且，数据大小异常检测电路44经由选择电路40获取与该源寄存器对应的状态信息Q。

然后，数据大小异常检测电路44判定状态信息Q的大小信息DS表示的大小与从命令解码电路21获取的源寄存器的大小是否一致。而且，在判定为不一致的情况下，数据大小异常检测电路44向异常信号生成电路42输出检测到数据大小异常这样的检测结果。

另外，W异常检测电路45是检测W异常的电路。为了进行W异常的检测，W异常检测电路45经由选择电路40获取与命令的源寄存器对应的状态信息Q。

然后，W异常检测电路45在该状态信息Q中的第一标志W为“0”的情况下，向异常信号生成电路42输出检测到W异常这样的检测结果。

并且，src数据类型异常检测电路46从命令解码电路21获取解码内容所包含的命令的种类。然后，src数据类型异常检测电路46基于该命令的种类，判断该命令是否以储存于两个源寄存器的数据类型相同为前提。

此时，在判断为以数据类型相同为前提时，src数据类型异常检测电路46经由选择电路40获取分别与命令的两个源寄存器对应的状态信息Q。

并且，src数据类型异常检测电路46判定该状态信息Q中的类型信息DT在两个源寄存器的各个中是否一致。而且，在两者不一致的情况下，src数据类型异常检测电路46向异常信号生成电路42输出检测到src数据类型异常这样的检测结果。

而且，R异常检测电路47是检测R异常的电路。为了进行R异常的检测，R异常检测电路47经由选择电路40获取与命令的源寄存器对应的状态信息Q、和与命令的目的寄存器对应的状态信息Q。然后，R异常检测电路47确定与目的寄存器对应的状态信息Q的第一标志W、和与源寄存器对应的状态信息Q的第二标志R。并且，R异常检测电路47在第一标志W为“1”，并且第二标志R为“0”的情况下，向异常信号生成电路42输出检测到R异常这样的检测结果。

此外，异常检测电路41在从执行电路30接收了后述的无效信号的情况下，不进行异常的检测。另外，在从执行电路30接收了后述的有效信号的情况下，异常检测电路41如上述那样进行异常的检测。

异常信号生成电路42输出与异常检测电路41的检测结果对应的异常信号。在该异常信号包含有异常的种类、命令的地址、以及寄存器的索引。

其中，作为异常的种类有“数据类型异常”、“数据大小异常”、“W异常”、“src数据类型异常”、以及“R异常”。例如，在得出数据类型异常检测电路43检测到异常这样的检测结果的情况下，在异常信号包含“数据类型异常”作为异常的种类。

另外，命令的地址是产生了异常的命令的地址。例如，通过异常信号生成电路42获取命令解码电路21保持的地址，异常信号生成电路42能够使异常信号包含命令的地址。

而且，寄存器的索引是被指定为产生了异常的命令的操作数的寄存器的索引。例如，异常信号生成电路42能够通过根据命令解码电路21输出的解码内容获取源寄存器和目的寄存器各自的索引，来使其包含于异常信号。

接下来，对该异常信号的输出目的地亦即异常处理电路25的功能进行说明。

图19是用于说明异常处理电路25的功能的示意图。

若接收异常信号，则异常处理电路25分别对命令解码电路21、数据获取电路22、命令执行电路23、以及回写电路24指示停止当前执行中的命令的执行。

然后，异常处理电路25参照储存于存储器28的异常向量表50，确定与接收的异常信号所包含的异常的种类对应的跳转目的地的地址。在图19的例子中，将W异常的跳转目的地的命令存储器28a的地址设为“0xAAAAAAAA”，将R异常的跳转目的地的地址设为“0xBBBBBBBB”。在这些地址的命令存储器28a预先储存有根据异常的种类而执行的异常处理程序。

之后，异常处理电路25对命令解码电路21通知确定出的跳转目的地的地址。然后，命令解码电路21取出位于通知的地址的命令。由此，在命令执行电路23中，执行与异常的种类对应的异常处理程序。

根据以上说明的处理器20，异常检测电路41利用储存于状态寄存器sxn、svn(n＝0、1、2、…、31)的状态信息Q，根据图17的检测规则检测异常。由此，在汇编存在记述错误的情况下，异常检测电路41检测异常，开发者能够基于该异常注意到在汇编程序存在记述错误。其结果是，开发者能够容易地调试汇编程序，能够实现程序开发的效率化。

并且，通过像这样由处理器20检测起因于记述错误的异常，在处理器20无用地执行有记述错误的程序的时间减少，能够改善处理器20、存储器28等硬件资源的不必要的消耗。

并且，在状态信息Q有第一标志W、第二标志R、类型信息DT、以及大小信息DS。通过在图17的检测规则应用这些信息，从而异常检测电路41能够检测“R异常”、“W异常”、“数据类型异常”、“数据大小异常”、以及“src数据类型异常”。因此，开发者能够根据检测到这些异常中的哪个异常，确定汇编中的具体的记述错误的种类。

然而，有在程序的执行时产生子流程调用、基于OS(Operating System：操作系统)的上下文切换的情况。该情况下，为了防止由于调用的子流程、其它的上下文而覆盖寄存器的数据，需要使位于各通用寄存器xn和向量寄存器vn的数据退避到数据存储器28b。而且，在返回到原来的程序的处理时，为了能够从中断处理之处重新开始程序，使退避到数据存储器28b的数据恢复到各通用寄存器xn和向量寄存器vn。

在本实施方式中，优选也对储存于与通用寄存器xn相对应地使用的状态寄存器sxn的状态信息Q进行退避和恢复。由于相同的理由，优选对状态寄存器svn也进行状态信息Q的退避和恢复。

因此，接下来，对能够进行储存于各状态寄存器sxn(n＝0、1、2、…、31)、svn(n＝0、1、2、…、31)的状态信息Q的退避和恢复的命令进行说明。

图20是示意性地表示本实施方式的storeStatus命令和loadStatus命令的图。

storeStatus命令是第一存储命令的一个例子，是将储存于状态寄存器sxn(n＝0、1、2、…、31)的状态信息Q保存于通用寄存器xn(n＝0、1、2、…、31)的命令。这里，对storeStatus命令的第一操作数指定通用寄存器xn(n＝0、1、2、…、31)之一作为目的寄存器。而且，对storeStatus命令的第二操作数指定状态寄存器sxn(n＝0、1、2、…、31)之一作为源寄存器。

执行电路30(参照图15)通过执行该storeStatus命令，将位于状态寄存器sxn(n＝0、1、2、…、31)的状态信息Q保存于通用寄存器xn(n＝0、1、2、…、31)。

此外，源寄存器与目的寄存器各自的索引不需要相同，也可以使状态信息Q在索引不同的寄存器间移动。

另外，关于利用storeStatus命令将保存于通用寄存器xn(n＝0、1、2、…、31)之一的状态信息Q保存于数据存储器28b，使用将通用寄存器xn(n＝0、1、2、…、31)的数据储存于数据存储器的store命令即可。

这样，执行电路30通过执行storeStatus命令和store命令，能够使状态寄存器sxn(n＝0、1、2、…、31)的状态信息Q退避到数据存储器28b。

另一方面，loadStatus命令是第一载入命令的一个例子，是将保存于通用寄存器xn(n＝0、1、2、…、31)的状态信息Q写入到状态寄存器sxn(n＝0、1、2、…、31)的命令。

这里，对loadStatus命令的第一操作数指定状态寄存器sxn(n＝0、1、2、…、31)之一作为目的寄存器。而且，对loadStatus命令的第二操作数指定通用寄存器xn(n＝0、1、2、…、31)之一作为源寄存器。

执行电路30(参照图15)通过执行该loadStatus命令，将保存于通用寄存器xn(n＝0、1、2、…、31)的状态信息Q写入到状态寄存器sxn(n＝0、1、2、…、31)。

与storeStatus命令相同，在loadStatus命令中，源寄存器与目的寄存器各自的索引也不需要相同，也可以使状态信息Q在索引不同的寄存器间移动。

此外，关于将退避到数据存储器28b的状态信息Q保存于通用寄存器xn(n＝0、1、2、…、31)之一，使用将数据存储器28b的数据写入到通用寄存器的load命令即可。

执行电路30(参照图15)能够通过执行上述那样的storeStatus命令、loadStatus命令，在状态寄存器sxn(n＝0、1、2、…、31)与数据存储器28b之间进行状态信息Q的退避、恢复。

此外，虽然在该例子中对storeStatus命令和loadStatus命令各自的操作数指定了状态寄存器sxn(n＝0、1、2、…、31)，但也可以代替该情况而指定状态寄存器svn(n＝0、1、2、…、31)。同样地，也可以代替对storeStatus命令和loadStatus命令各自的操作数指定的通用寄存器xn(n＝0、1、2、…、31)而使用向量寄存器vn(n＝0、1、2、…、31)。

另外，在图20的例子中，经由通用寄存器xn(n＝0、1、2、…、31)进行数据存储器28b与状态寄存器sxn(n＝0、1、2、…、31)之间的状态信息Q的退避和恢复。

也可以不像这样经由通用寄存器xn(n＝0、1、2、…、31)进行状态信息Q的退避和恢复，而通过利用以下那样的命令，在状态寄存器sxn(n＝0、1、2、…、31)与数据存储器28b之间直接进行状态信息Q的退避和恢复。

图21是示意性地表示本实施方式的saveStatus命令和loadStatus命令的图(其一)。

saveSatus命令是第二存储命令的一个例子，是将储存于状态寄存器sxn(n＝0、1、2、…、31)的状态信息Q保存于数据存储器28b的命令。

这里，对saveStatus命令的第一操作数指定地址，对第二操作数指定状态寄存器sxn(n＝0、1、2、…、31)。执行电路30通过执行该saveStatus命令，将位于第二操作数的状态寄存器sxn(n＝0、1、2、…、31)的状态信息Q保存于第一操作数的地址的数据存储器28b。

此外，关于将保存于数据存储器28b的状态信息Q保存于状态寄存器sxn(n＝0、1、2、…、31)，利用loadStatus命令即可。

但是，为了与如图20那样进行寄存器间的数据的转送的loadStatus命令相区分，这里利用与图20不同的格式记述loadStatus命令。在图21的例子中，对loadStatus命令的第一操作数指定状态寄存器sxn(n＝0、1、2、…、31)，对第二操作数指定地址。执行电路30通过执行该格式的loadStatus命令，将位于第二操作数的地址的数据存储器28b的状态信息Q写入到第一操作数的状态寄存器sxn(n＝0、1、2、…、31)。此外，采用了该格式的loadStatus命令是第二载入命令的一个例子。

这样，执行电路30若执行saveStatus命令和loadStatus命令，则能够不经由通用寄存器xn(n＝0、1、2、…、31)而进行状态信息Q的退避和恢复，所以能够使程序的执行速度高速化。

此外，在图20和图21的例子中，状态信息Q的退避目的地、恢复目的地仅为一个寄存器，但如以下那样也有在全部的寄存器一并地进行退避和恢复的便利的情况。

图22是示意性地表示本实施方式的saveStatus命令和loadStatus命令的图(其二)。

与图21的取两个操作数的saveStatus命令的格式不同，在该例子中，将saveStatus命令记述为开发者仅取一个操作数。执行电路30通过执行该saveStatus命令，将储存于全部的状态寄存器sxn、svn(n＝0、1、…31)的全部的状态信息Q一并保存于操作数的地址的数据存储器28b。此外，该saveStatus命令是第三存储命令的一个例子。

另一方面，loadStatus命令也与如图21那样取两个操作数的格式不同，记述为仅取指定地址的一个操作数。执行电路30通过执行该loadStatus命令，一并将位于指定的地址的数据存储器28b的全部的状态信息Q分别写入到对应的各状态寄存器sxn、svn(n＝0、1、…31)。此外，该loadStatus命令是第三载入命令的一个例子。

使用图20～图22中的哪个命令进行状态信息Q的退避和恢复并不特别限定。但是，在上下文切换的情况下，优选开发者基于ABI(Application Binary Interface：应用二进制接口)决定使用哪个命令。ABI是对每个处理器规定根据调用子流程的一侧(caller：调用者)的责任进行退避和恢复的寄存器、和根据被调用的一侧(callee：被调用者)的责任进行退避和恢复的寄存器的协议。

例如，在处理器20依据ARMv8-A架构的情况下，规定callee侧进行通用寄存器x19～x28和向量寄存器v8～v15各自中的数据的退避和恢复。根据该协议，与进行数据的退避和恢复配合地，也对与这些寄存器对应的状态寄存器sx19～sx28、sv8～sv15所储存的状态信息Q进行退避和恢复。在这种情况下，若如图22那样使用在全部的状态寄存器与数据存储器28b之间进行退避和恢复的命令，则需要也对不需要进行退避、恢复的寄存器的数据进行处理，而程序的执行速度降低。由此，在子流程调用的情况下，优选如图20或者图21那样使用按照每个状态寄存器sxn、svn(n＝0、1、…31)进行退避、恢复的命令，使程序的执行速度提高。

另一方面，在OS的上下文切换的情况下，对全部的通用寄存器x0～x31和全部的向量寄存器v0～v31的数据进行退避和恢复。由此，在上下文切换的情况下，优选如图22那样使用在全部的状态寄存器与数据存储器28b之间进行退避和恢复的命令，减小程序的代码大小。

然而，虽然在处理器20中，如上述那样异常信号生成电路42对开发者自己记述的汇编语言的源代码的记述错误输出异常信号，但根据情况也有不需要异常信号的情况。

例如，有在不是开发者手动地记述的汇编语言的源代码，而是编译器输出的汇编语言的源代码，由于编译器的优化不足而包含有无意义的命令的情况。若异常检测电路41对该命令检测异常，则在脱离检测手动所引起的错误这样的目的的情况下也检测异常，而成为异常的过检测，变得麻烦。

因此，在本实施方式中，如以下那样抑制异常检测电路41的功能。

图23的(a)是抑制异常检测电路41的功能时的汇编语言的源代码的示意图。

在该源代码53中，开发者在不想检测异常的命令列53a之前记述disableExeptGen命令。而且，开发者在该命令列53a之后记述enableExeptGen命令。此外，disableExeptGen命令是无效命令的一个例子，enableExeptGen命令是有效命令的一个例子。

执行电路30若执行disableExeptGen命令，则执行电路30对异常检测电路41(参照图18)通知无效信号。无效信号是使进行异常的检测这样的异常检测电路41的功能无效的信号。由此，接受了该无效信号的异常检测电路41不进行命令列53a中的异常的检测。其结果是，即使假设在命令列53a包含产生异常那样的记述错误，异常信号生成电路42也不生成异常信号。

另外，若命令列53a的执行结束而执行电路30执行enableExeptGen命令，则执行电路30对异常检测电路41通知有效信号。有效信号是使检测异常这样的异常检测电路41的功能有效的信号。由此，接受了该有效通知的异常检测电路41在enableExeptGen命令的后续命令中进行异常的检测。由此，在enableExeptGen命令的后续的命令列53b中产生了异常的情况下，异常信号生成电路42生成异常信号。

这样通过利用disableExeptGen命令和enableExeptGen命令，能够抑制在命令列53a的执行时产生异常信号，或者使异常信号的产生重新开始。

此外，也可以如以下那样分别在disableExeptGen命令和enableExeptGen命令中记述操作数。

图23的(b)是在disableExeptGen命令中记述了操作数的例子的示意图。

在该例子中，开发者对disableExeptGen命令的第一操作数记述多个状态寄存器sxn、svn(n＝0、1、2、…、31)中的一个。而且，开发者对第二操作数记述识别多个异常的种类的各个的标识符。这里，将W异常的标识符设为“W”，将R异常的标识符设为“R”，将数据类型异常的标识符设为“DataType”，将数据大小异常的标识符设为“DataSize”，并将src数据类型异常的标识符设为“SrcDataType”。

若执行电路30执行该格式的disableExeptGen命令，则使用位于第一操作数的状态寄存器sxn、svn的状态信息Q检测第二操作数的异常这样的异常检测电路41的功能变得无效。例如，在记述为“disableExeptGen sx0，W|R”的情况下，使用储存于状态寄存器sx0的状态信息Q检测W异常和R异常的功能变得无效。

另一方面，图23的(c)是在enableExeptGen命令中记述了操作数的例子的示意图。

在该例子中，开发者对enableExeptGen命令的第一操作数记述多个状态寄存器sxn、svn(n＝0、1、…31)中的一个。而且，开发者对第二操作数记述识别多个异常的种类的各个的标识符。

若执行电路30执行该格式的enableExeptGen命令，则使用位于第一操作数的状态寄存器sxn、svn(n＝0、1、…31)的状态信息Q检测第二操作数的异常这样的异常检测电路41的功能变得有效。例如，在记述为“enableExeptGen sx0，W”的情况下，使用储存于状态寄存器sx0的状态信息QW判定是否生成异常的功能变得有效。

这样，通过分别在disableExeptGen命令和enableExeptGen命令中记述操作数，能够选择检测对象的异常的种类。并且，能够指定检测该异常所使用的状态信息Q的储存目的地亦即状态寄存器，开发者的便利性提高。

(第二实施方式)

在本实施方式中，对模拟在第一实施方式进行了说明的处理器20的动作的模拟程序进行说明。

图24是执行模拟程序的信息处理装置的硬件构成图。

该信息处理装置60是PC(Personal Computer：个人计算机)等计算机，具有存储装置60a、存储器60b、处理器60c、通信接口60d、显示装置60e、以及输入装置60f。这些各部通过总线60g相互连接。

其中，存储装置60a是HDD(Hard Disk Drive：硬盘驱动器)、SSD(Solid StateDrive：固盘)等非易失性的存储设备，存储本实施方式的模拟程序61。

此外，也可以使模拟程序61预先记录于计算机能够读取的记录介质60h，并使处理器60c读取记录介质60h的模拟程序61。

作为这样的记录介质60h，例如有CD-ROM(Compact Disc-Read Only Memory：只读光盘)、DVD(Digital Versatile Disc：数字多用盘)、以及USB(Universal Serial Bus：通用串行总线)存储器等物理上的便携式记录介质。另外，也可以使用闪存等半导体存储器、硬盘驱动器作为记录介质60h。这些记录介质60h不是不具有物理性形态的载波那样的暂时的介质。

并且，也可以使模拟程序61预先存储于与公用线路、因特网、以及LAN(Local AreaNetwork：局域网)等连接的装置，处理器60c读出该程序61并执行。

另一方面，存储器60b是DRAM等那样暂时存储数据的硬件，在其上展开上述的模拟程序61。

处理器60c是控制信息处理装置60的各部或者与存储器60b配合地执行模拟程序61的CPU(Central Processing Unit：中央处理器)、GPU(Graphical Processing Unit：图形处理器)等硬件。

并且，通信接口60d是用于使信息处理装置60与LAN等网络连接的接口。

而且，显示装置60e是液晶显示装置等硬件，对开发者显示各种信息。另外，输入装置60f是键盘或者鼠标等硬件。例如，开发者通过操作输入装置60f，对信息处理装置60发出各种指示。

图25是信息处理装置60执行模拟程序61时的信息处理装置60的功能构成图。

如图25所示，信息处理装置60具备控制部63和存储部64。

其中，控制部63是通过由处理器60c和存储器60b执行模拟程序61实现的处理部，具有环境构建部65和模拟执行部66。

环境构建部65是生成模拟了处理器20的伪处理器的处理部。另外，模拟执行部66是受理来自开发者的指示，利用环境构建部65生成的伪处理器执行模拟的处理部。

另一方面，存储部64通过存储装置60a和存储器60b实现，存储模拟对象的处理器20(参照图15)执行的机器语言的可执行程序67。该可执行程序67是对开发者手动记述的汇编语言的源代码进行汇编得到的机器语言的程序。

此外，信息处理装置60中的处理器60c不需要与模拟对象的处理器20相同，也可以是执行与处理器20不同的指令集的处理器。由此，即使在模拟对象的处理器20不在身边的状况下也能够模拟其动作，而处理器20执行的可执行程序的开发效率提高。

图26是环境构建部65生成的伪处理器70的功能框图。

伪处理器70具有命令解码部71、数据获取部72、命令执行部73、回写部74、异常处理部75、状态寄存器文件部76、以及运算用寄存器文件部77。并且，伪处理器70具有具备命令存储器部78a和数据存储器部78b的存储器部78。

这些各部以软件的方式实现第一实施方式的处理器20的各部的功能，并通过存储器60b与处理器60c配合地执行模拟程序61来实现。

图27是表示第一实施方式的处理器20的各部与本实施方式的伪处理器70的各部之间的对应关系的图。

在图27中，以箭头示出具有相同的功能的元素彼此。例如，命令解码部71是以软件的方式实现命令解码电路21的功能模块，具有与命令解码电路21相同的功能。

另外，命令解码部71以外的各部也具有与处理器20中对应的元素相同的功能。其功能在第一实施方式进行了说明，所以以下省略其说明。

此外，以软件实现伪处理器70的各部的具体的方法并不特别限定。例如，由在存储器60b确保的第一存储区域77a实现运算用寄存器文件部77。而且，由在第一存储区域77a储存的数组元素实现运算用寄存器文件部77的通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)，数组元素的索引成为各寄存器的索引。

同样地，由在存储器60b确保的第二存储区域76a实现状态寄存器文件部76。而且，由在第二存储区域76a储存的数组元素实现状态寄存器文件部76的状态寄存器sxn、svn(n＝0、1、2、…、31)，数组元素的索引成为各状态寄存器的索引。

另外，能够利用在存储器60b确保的第三存储区域78c模拟存储器28。

接下来，对本实施方式的模拟方法进行说明。

图28是用于说明本实施方式的模拟方法的流程图。

首先，环境构建部65生成伪处理器70的各部(步骤S11)。例如，环境构建部65在存储器60b确保模拟通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)的第一存储区域77a、和模拟状态寄存器sxn、svn(n＝0、1、2、…、31)的第二存储区域76a。另外，为了模拟存储器28，环境构建部65在存储器60b确保第三存储区域78c。

然后，环境构建部65读入可执行程序67并将其储存于命令存储器部78a(步骤S12)。

接下来，环境构建部65将状态寄存器文件部76初始化(步骤S13)。例如，环境构建部65将状态寄存器文件部76中的模拟状态寄存器sxn、svn(n＝0、1、2、…、31)的数组初始化。例如，W标志和R标志分别设定为0，数据类型DT与数据大小DS分别设定为表示不确定的位串。

接下来，命令解码部71读出储存于命令存储器部78a的机器语言的命令(步骤S14)。

然后，命令解码部71对该命令进行解码，并将解码内容分别输出到数据获取部72、命令执行部73、以及回写部74(步骤S15)。作为解码内容，有命令的种类、源寄存器和目的寄存器各自的索引、源寄存器的元素的数据大小、源寄存器的数据类型等。

接下来，数据获取部72基于解码内容，从运算用寄存器文件部77和数据存储器部78b的任意一方读出数据，并将其输出给命令执行部73(步骤S16)。

接下来，执行部83执行命令(步骤S17)。

然后，命令执行部73的第一异常检测部82a检测与汇编语言的记述错误无关的异常(步骤S18)。作为这样的异常，有想要执行未安装命令时的异常、使用除以零时的异常。

并且，在步骤S18中，命令执行部73的第二异常检测部82b检测起因于汇编语言的记述错误的异常。例如，第二异常检测部82b基于位于状态寄存器文件部76的状态信息Q、和命令解码部71输出的解码内容检测异常。此外，后述第二异常检测部82b进行的异常检测处理的详细。

接下来，第一异常检测部82a和第二异常检测部82b分别基于异常检测处理的结果，判定是否检测到异常(步骤S19)。

这里，在判断为第一异常检测部82a和第二异常检测部82b的任何一个均未检测到异常的情况下(步骤S19：否定)，执行部83将命令的执行结果输出到回写部74(步骤S20)。

另一方面，在判断为第一异常检测部82a检测到异常的情况下(步骤S19：肯定)，第一异常检测部82a生成异常信号并将其输出到异常处理部75(步骤S20)。此外，在判断为第二异常检测部82b检测到异常的情况下(步骤S19：肯定)，第二异常检测部82b生成异常信号并将其输出到异常处理部75(步骤S20)。

然后，接受了该异常信号的异常处理部75根据异常向量表50(参照图19)确定跳转目的地的地址，并将确定出的跳转目的地的地址通知给命令解码部71(步骤S21)。

之后，对可执行程序67的各命令反复进行步骤S14～S22。然后，若对可执行程序67的全部的命令结束S14～S22，则结束本实施方式的模拟方法。

接下来，对步骤S18的异常检测处理进行说明。

图29是步骤S18的异常检测处理的流程图。

首先，第二异常检测部82b检查是否有数据类型异常(步骤S31)。例如，第二异常检测部82b从状态寄存器文件部76读出在步骤S17执行的命令的源寄存器的状态信息Q。而且，在该状态信息Q的类型信息DT表示的数据类型与命令设为运算的对象的数据类型不一致的情况下，第二异常检测部82b检测到数据类型异常。

接下来，第二异常检测部82b使用在步骤S31读出的状态信息Q，检查是否有数据大小异常(步骤S32)。例如，在该状态信息Q的大小信息DS表示的数据大小与在步骤S17执行的命令中源寄存器所期待的数据大小不一致的情况下，第二异常检测部82b检测到数据大小异常。

接下来，第二异常检测部82b检查是否有W异常(步骤S33)。使用在步骤S31读出的状态信息Q进行该检查。例如，在状态信息Q中的第一标志W为“0”的情况下，第二异常检测部82b检测到W异常。

接着，第二异常检测部82b基于该状态信息Q的第一标志W和第二标志R检查是否有R异常(步骤S34)。作为一个例子，在第一标志W为“1”，并且第二标志R为“0”的情况下，第二异常检测部82b检测到R异常。

接下来，第二异常检测部82b检查是否有src数据类型异常(步骤S35)。例如，第二异常检测部82b判断在步骤S17执行的命令是否是以两个源寄存器的数据类型相同为前提的命令。这里，在判断为是以两个源寄存器的数据类型相同为前提的命令时，第二异常检测部82b从状态寄存器文件部76读出该命令的各源寄存器的状态信息Q。而且，在这些状态信息Q各自的类型信息DT表示的数据大小彼此不一致的情况下，异常检测部82检测到src数据类型异常。

通过以上，结束步骤S18的异常检测处理。

根据以上进行了说明的本实施方式，即使未在第一实施方式的处理器20中实际执行可执行程序67的命令，也能够利用信息处理装置60检查在该可执行程序67是否有记述错误。

并且，由于像这样能够利用信息处理装置60检查记述错误，所以在处理器20中无用地执行有记述错误的程序的时间减少，能够改善处理器20、存储器28等硬件资源的不必要的消耗。

并且，在步骤S18的异常检测处理中，与第一实施方式相同地利用状态信息Q检测异常。因此，能够分别检测开发者手动地记述汇编时的错误所引起的数据类型异常、数据大小异常、W异常、R异常、以及src数据类型异常。而且，开发者能够基于该异常进行调试，能够提高汇编语言的程序的开发效率。

此外，本实施方式并不限定于上述。

例如，也可以由执行部83执行在第一实施方式的图20～图22进行了说明的loadStatus命令、storeStatus命令、以及saveStatus命令。由此，能够进行在第二存储区域76a(参照图27)模拟的状态寄存器sxn、svn(n＝0、1、2、…、31)的数据的退避、恢复，能够模拟子流程调用、OS的上下文切换。

并且，开发者也可以在汇编语言的源代码记述第一实施方式的图23的(a)～(c)的disableExceptGen命令、enableExceptGen命令，使异常检测部82检测异常的功能无效或者有效。

(第三实施方式)

在第一实施方式中，在处理器20执行可执行程序时，处理器20检测起因于汇编语言的记述错误的异常。

与此相对，在本实施方式中，在有汇编语言的记述错误的情况下，根据汇编语言生成机器语言的可执行程序的汇编程序输出错误。

图30是在本实施方式中执行可执行程序的目标机具备的处理器90的构成图。

此外，在图30中，对与第一实施方式的在图15进行了说明的元素相同的元素附加与图15中的附图标记相同的附图标记，以下省略其说明。

在本实施方式中，与第一实施方式不同，处理器90不利用储存于状态寄存器文件26(参照图15)的状态信息Q来检测异常。因此，该处理器90具有从第一实施方式的处理器20省去了状态寄存器文件26、状态更新电路31、以及第二异常检测部32b后的硬件构成。这些电路以外的各部的动作与第一实施方式相同。

如以下那样利用本实施方式的汇编程序生成在该处理器90执行的机器语言的可执行程序。

图31是执行本实施方式的汇编程序的信息处理装置的硬件构成图。

该信息处理装置100是PC等计算机，具有存储装置100a、存储器100b、处理器100c、通信接口100d、显示装置100e、以及输入装置100f。这些各部通过总线100g相互连接。

存储装置100a是HDD、SSD等非易失性的存储设备，存储本实施方式的汇编程序112。

此外，也可以预先使汇编程序112记录于计算机能够读取的记录介质100h，并使处理器100c读取记录介质100h的汇编程序112。

作为这样的记录介质100h，例如有CD-ROM、DVD、以及USB存储器等物理上的便携式记录介质。另外，也可以使用闪存等半导体存储器或者硬盘驱动器作为记录介质100h。这些记录介质100h不是不具有物理性形态的载波那样的暂时的介质。

并且，也可以预先使汇编程序112存储于与公用线路、因特网、以及LAN等连接的装置，处理器100c读出该汇编程序112并执行。

另一方面，存储器100b是DRAM等那样暂时存储数据的硬件，在其上展开上述的汇编程序112。

处理器100c是控制信息处理装置100的各部或者与存储器100b配合地执行汇编程序112的CPU、GPU等硬件。

并且，通信接口100d是用于将信息处理装置100与LAN等网络连接的接口。

而且，显示装置100e是液晶显示装置等硬件，对开发者显示各种信息。另外，输入装置100f是键盘、鼠标等硬件。例如，开发者通过操作输入装置100f，对信息处理装置100发出各种指示。

图32是信息处理装置100执行汇编程序112时的信息处理装置100的功能构成图。

如图32所示，信息处理装置100具备控制部101和存储部102。

其中，存储部102由存储装置100a和存储器100b实现，存储成为汇编的对象的汇编语言的源程序109。另外，存储部102也存储判定在该汇编语言的源程序109是否有记述错误所使用的状态信息110。后述该状态信息110的详细。

并且，存储部102也存储对汇编语言的源程序109进行汇编得到的机器语言的可执行程序111。

另一方面，控制部101具有初始化部103、获取部104、异常检测部105、错误输出部106、状态更新部107、以及机器语言生成部108。

其中，初始化部103是在汇编之前对状态信息110进行初始化的处理部。另外，获取部104是从存储部102获取汇编对象的汇编语言的源程序109的处理部。

异常检测部105是基于状态信息110，检测源程序109所记述的命令中的异常的处理部。例如，若获取部104获取包含通用寄存器xn(n＝0、1、2、…、31)、向量寄存器vn(n＝0、1、2、…、31)被指定为操作数的命令的汇编语言的代码，则异常检测部105检测该命令中的异常。

而且，错误输出部106是在异常检测部105检测到异常时输出错误的处理部。

另一方面，状态更新部107是在异常检测部105未检测到异常时更新状态信息110的内容的处理部。而且，机器语言生成部108是在异常检测部105未检测到异常时，对汇编语言的代码进行汇编生成机器语言，并将包含该机器语言的可执行程序111写出到存储部102的处理部。

接下来，对状态信息110进行说明。

状态信息110是表示设置于运算用寄存器文件27(参照图30)的通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)各自的状态的信息。状态信息110的实现方法并不特别限定，但在本实施方式中以数组实现状态信息110。

图33是表示本实施方式的状态信息的C++的源代码的示意图。

在该状态信息110中，代码T20是声明表示通用寄存器xn(n＝0、1、2、…、31)和向量寄存器vn(n＝0、1、2、…、31)各自的数据大小的列举型“dataSize_t”的成员变量的代码。作为该成员变量，有表示字节的“sizeB”、表示半字的“sizeH”、表示单字的“sizeS”、表示双字的“sizeD”、以及表示128位的“sizeX”。

另外，在代码T20中，也作为列举型“dataSize_t”的成员变量而声明表示在通用寄存器xn(n＝0、1、2、…、31)、向量寄存器vn(n＝0、1、2、…、31)不储存数据而数据大小不确定的“CLEAN”。

代码T21是声明用于储存在向量寄存器vn(n＝0、1、…31)储存的向量数据的元素的数据大小的数组的代码。这里，声明数组“dataSizeVReg”作为向量寄存器vn(n＝0、1、2、…、31)用的数组。

此外，该数组“dataSizeVReg”各元素是表示储存于对应的向量寄存器的向量数据的元素的数据大小的类型信息的一个例子。

另外，在本实施方式中，数组元素的索引表示寄存器的索引。例如，dataSizeVReg[0]、dataSizeVReg[1]、…dataSizeVReg[31]表示向量寄存器v0、v1、…v31各自的数据大小。

此外，在该例子中，在代码T21中将各数组“dataSizeVReg”的全部的元素初始化为“CLEAN”。

另一方面，代码T22是声明表示通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)各自的数据类型的列举型“dataType”的成员变量的代码。作为该成员变量，有表示无符号整数的“typeUnsigned”、表示有符号整数的“typeSigned”、以及表示浮点小数的“typeFloat”。

另外，在代码T22中，也作为列举型“dataType_t”的成员变量而声明表示在通用寄存器xn(n＝0、1、…31)、向量寄存器vn(n＝0、1、…31)不储存数据而数据类型不确定的“CLEAN”。

代码T23是声明用于储存通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)各自的数据类型的数组的代码。在本实施方式中，声明数组“dataTypeGReg”作为通用寄存器xn用的数组，并声明数组“dataTypeVReg”作为向量寄存器用的数组。

此外，这些数组“dataTypeGReg”、“dataTypeVReg”各自的元素是表示储存于对应的寄存器的数据的数据类型的类型信息的一个例子。

另外，与数据大小的例子相同，在代码T23中数组元素的索引也表示寄存器的索引。例如，dataTypeGReg[0]、dataTypeGReg[1]、…dataTypeGReg[31]表示通用寄存器x0、x1、…x31各自的数据大小，dataTypeVReg[0]、dataTypeVReg[1]、…dataTypeVReg[31]表示向量寄存器v0、v1、…v31各自的数据大小。

此外，在该例子中，在代码T23中将数组“dataTypeGReg”、“dataTypeVReg”的全部的元素初始化为“CLEAN”。

而且，代码T24是声明表示通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)的各个是否已被用作源寄存器的列举型“readAccess_t”的成员变量的代码。作为该成员变量，有表示未被用作源寄存器的“FALSE”、和表示已被用作源寄存器的“TRUE”。

代码T25是声明用于储存列举型“readAccess_t”的成员变量的数组的代码。这里，声明数组“readAccessGReg”作为通用寄存器xn(n＝0、1、…31)用的数组，并声明数组“readAccessVReg”作为向量寄存器vn(n＝0、1、…31)用的数组。

此外，数组“readAccessGReg”、“readAccessVReg”各自的元素是表示对应的寄存器是否已被用作源寄存器的第二标志的一个例子。

另外，这些数组“readAccessGReg”、“readAccessVReg”各自的元素的索引与寄存器的索引相等。例如，readAccessGReg[0]、readAccessGReg[1]、…readAccessGReg[31]分别与通用寄存器x0、x1、…x31对应，readAccessVReg[0]、readAccessVReg[1]、…readAccessVReg[31]与向量寄存器v0、v1、…v31对应。

另一方面，代码T26是声明表示通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)的各个是否已被用作目的寄存器的列举型“writeAccess_t”的成员变量的代码。作为该成员变量，有表示未被用作目的寄存器的“FALSE”、和表示已被用作目的寄存器的“TRUE”。

代码T27是声明用于储存列举型“writeAccess_t”的成员变量的数组的代码。这里，声明数组“writeAccessGReg”作为通用寄存器xn(n＝0、1、…31)用的数组，并声明数组“writeAccessVReg”作为向量寄存器vn(n＝0、1、…31)用的数组。

此外，数组“writeAccessGReg”、“writeAccessVReg”各自的元素是表示对应的寄存器是否已被用作目的寄存器的第一标志的一个例子。

另外，这些数组“writeAccessGReg”、“writeAccessVReg”各自的元素的索引与寄存器的索引相等。例如，writeAccessGReg[0]、writeAccessGReg[1]、…writeAccessGReg[31]分别与通用寄存器x0、x1、…x31对应，writeAccessVReg[0]、writeAccessVReg[1]、…writeAccessVReg[31]与向量寄存器v0、v1、…v31对应。

这样，这里通过数组“dataSizeVReg”、“dataTypeGReg”、“dataTypeVReg”、“readAccessGReg”、“readAccessVReg”、“writeAccessVReg”、以及“writeAccessVReg”实现状态信息110。在异常检测部105未检测到异常时，通过状态更新部107更新这些数组的元素。

例如，在对于源寄存器被指定为操作数的命令没有异常时，状态更新部107在与该源寄存器对应的“readAccessGReg”或者“readAccessVReg”的元素储存“TRUE”。

而且，在对于目的寄存器被指定为操作数的命令没有异常时，状态更新部107也更新各数组的元素。该情况下，状态更新部107在与目的寄存器对应的数组“writeAccessGReg”或者“writeAccessVReg”的元素储存“TRUE”。并且，状态更新部107在与该目的寄存器对应的数组“readAccessGReg”或者“readAccessVReg”的元素储存“FALSE”。由此，该目的寄存器被设定为在写入数据后还未被用作源寄存器的状态。

另外，当在汇编语言的源程序109存在在寄存器写入数据的命令时，状态更新部107更新与该寄存器对应的数组“dataTypeGReg”或者“dataTypeVReg”。例如，考虑在源程序109记述代码“add x2，x0，x1”的情况。add命令是有符号64位整数的加法命令。由此，该情况下，状态更新部107在与通用寄存器x2对应的“dataTypeGReg[2]”储存“typeSigned”。这样，状态更新部107在数组“dataTypeGReg”或者“dataTypeVReg”的元素储存“typeUnsigned”、“typeSigned”、以及“typeFloat”中的命令设为运算的对象的数据类型。

同样地，当在汇编语言的源程序109存在在向量寄存器写入数据的命令时，状态更新部107更新与该向量寄存器对应的数组“dataSizeVReg”。例如，考虑在源程序109记述“vadd v3.s，v0.s，v1.s”的情况。该情况下，指定单字“s”作为写入到目的寄存器亦即向量寄存器v3的数据的大小。因此，该情况下，状态更新部107在与向量寄存器v3对应的“dataSizeVReg[3]”储存“sizeS”。这样，状态更新部107在数组“dataSizeVReg”的元素储存“sizeB”、“sizeH”、“sizeS”、“sizeD”、以及“sizeX”中的目的寄存器所指定的数据大小。

接下来，对异常检测部105检测异常时的检测规则进行说明。

图34的(a)是示意性地表示通用寄存器被指定为操作数xn(n＝0、1、2…31)的情况下的检测规则的图。

如图34的(a)所示，在通用寄存器被指定为操作数的情况下异常检测部105设为检测对象的异常有在第一实施方式的图17进行了说明的“W异常”、“R异常”、“数据类型异常”、以及“src数据类型异常”。

其中，W异常是在某一命令的源寄存器在该命令的先行命令中未被用作目的寄存器的情况下产生的异常，能够利用数组“writeAccessGReg”检测。

例如，考虑某一命令的源寄存器为通用寄存器x0的情况。在与该通用寄存器x0对应的“writeAccessGReg[0]”为“FALSE”的情况下，该通用寄存器x0在过去未被用作目的寄存器。由此，异常检测部105在“writeAccessGReg[0]”为“FALSE”的情况下检测到W异常。

另外，R异常是在后续命令使用在先行命令写入了数据的寄存器作为目的寄存器的情况下，在先行命令和后续命令之间的全部的命令未使用该寄存器作为源寄存器的情况下的异常。能够利用数组“writeAccessGReg”和数组“readAccessGReg”检测该R异常。

例如，考虑某一命令的目的寄存器为通用寄存器x0的情况。在该通用寄存器x0在过去已经在其它的命令中用作目的寄存器的情况下，“writeAccessGReg[0]”为“TRUE”。另外，在该通用寄存器x0在之后的命令中未被用作源寄存器的情况下，“readAccessGReg[0]”为“FALSE”。由此，异常检测部105在“writeAccessGReg[0]”为“TRUE”，并且“readAccessGReg[0]”为“FALSE”的情况下检测到R异常。

另外，数据类型异常是在命令设为运算的对象的数据类型与写入到源寄存器的实际的数据的数据类型不一致的情况下产生的异常。

能够利用数组“dataTypeGReg”检测数据类型异常。例如，考虑获取部104获取的汇编语言的代码为“fadd x2，x0，x1”的情况。该情况下，异常检测部105根据汇编语言的代码中的“fadd”的记述确定命令的种类为fadd，确定该命令设为运算的对象的数据的数据类型为“typeFloat”。并且，异常检测部105基于上述的代码的第二操作数的“x0”的记述，确定该命令的源寄存器为通用寄存器x0。

另一方面，在与通用寄存器x0对应的数组“dataTypeGReg”的元素亦即“dataTypeGReg[0]”储存有“typeUnsigned”。该情况下，“dataTypeGReg[0]”与“typeFloat”不一致。异常检测部105在像这样“dataTypeGReg[0]”与“typeFloat”不一致的情况下检测到数据类型错误。

此外，虽然在该例子中异常检测部105检测第二操作数“x0”的数据类型异常，但异常检测部105也能够利用相同的方法检测第三操作数“x1”的数据类型异常。

而且，src数据类型异常是在命令的两个源寄存器各自的数据类型不一致的情况下产生的异常。

能够利用数组“dataTypeGReg”检测src数据类型异常。

例如，考虑获取部104获取的汇编语言的代码为“multiply x2，x0，x1”的情况。该情况下，异常检测部105根据汇编语言的代码中的“multiply”的记述确定命令的种类为“multiply”。而且，异常检测部105基于确定出的multiply命令是以两个源寄存器的数据类型相同为前提的命令，对储存于通用寄存器x0、x1的数据的数据类型进行比较。

这里，假设储存于通用寄存器x0的数据类型为无符号整数，而“dataTypeGReg[0]”为“typeUnsigned”。另一方面，假设储存于通用寄存器x1的数据类型为浮点小数，而“dataTypeGReg[1]”为“typeFloat”。该情况下“dataTypeGReg[0]”与“dataTypeGReg[1]”不一致。异常检测部105在像这样“dataTypeGReg[0]”与“dataTypeGReg[1]”不一致的情况下检测到src数据类型异常。

另一方面，图34的(b)是示意性地表示向量寄存器被指定为操作数vn(n＝0、1、2…31)的情况下的检测规则的图。

在向量寄存器的情况下，也能够根据与图34的(a)的通用寄存器的情况相同的检测规则检测“W异常”、“R异常”、“数据类型异常”、以及“src数据类型异常”。

并且，在向量寄存器的情况下也有用于检测“数据大小异常”的检测规则。

数据大小异常是在先行命令写入到寄存器的数据的数据大小与在将该寄存器作为源寄存器的后续命令中指定的源寄存器的数据大小不同的情况下产生的异常。能够利用数组“dataSizeVReg”检测该数据大小异常。

例如，考虑获取部104获取的汇编语言的代码为“vadd v2.s，v0.s，v1.s”的情况。该情况下，异常检测部105基于第二操作数的“v0.s”的记述，确定该vadd命令的源寄存器所指定的数据大小为“sizeS”。并且，异常检测部105基于第二操作数的“v0.s”的记述，也确定该vadd命令的源寄存器为向量寄存器v0。

另一方面，假设在与向量寄存器v0对应的数组“dataSizeVReg”的元素亦即“dataSizeVReg[0]”储存有“sizeB”。该情况下，“dataSizeVReg[0]”与“sizeS”不一致。异常检测部105在像这样“dataSizeVReg[0]”与“sizeS”不一致的情况下检测到数据大小异常。

此外，虽然在该例子中异常检测部105检测“vadd v2.s，v0.s，v1.s”的第二操作数“v0.s”的数据大小异常，但也能够利用相同的方法检测第三操作数“v1.s”的数据大小异常。

根据以上说明的信息处理装置100，异常检测部105利用状态信息110，根据图34的(a)、(b)的检测规则在汇编时检测异常。由此，在汇编语言的源程序109有记述错误的情况下异常检测部105检测异常，开发者能够基于该异常注意到在源程序109有记述错误。其结果是，开发者能够容易地调试源程序109，能够实现程序开发的效率化。

并且，在状态信息110定义有用于检测“W异常”、“数据类型异常”、“数据大小异常”、以及“src数据类型异常”的数组。因此，异常检测部105能够基于该状态信息110，确定产生了上述的各异常中的哪个异常。而且，开发者能够根据检测到这些异常的哪个异常，确定源程序109中的具体的记述错误。

然而，虽然若异常检测部105像这样检测异常则能够发现汇编语言的源程序109中的记述错误，但根据情况，也有使异常检测部105检测异常的功能无效更便利的情况。

例如，如在第一实施方式中进行了说明的那样，有由于编译器的优化不足而在源程序109包含无意义的汇编语言的代码的情况。若异常检测部105对这样的代码检测异常，则在脱离检测手动所引起的错误这样的目的的情况下也检测异常，而较麻烦。

因此，在本实施方式中，如以下那样抑制异常检测部105的功能。

图35是抑制异常检测部105的功能时的汇编语言的源程序109的示意图。

在该源程序109中，开发者在不想要检测异常的命令列109a之前，记述作为汇编语言的指令的“.disable_check”。“.disable_check”是使异常检测部105检测异常的处理无效的指令。

而且，开发者在该命令列109a之后记述指令“.enable_check”。“.enable_check”是使异常检测部105检测异常的处理有效的指令。

异常检测部105在获取部104获取了指令“.disable_check”的情况下，不对该指令的后续命令进行检测异常的处理。由此，即使在命令列109a包含产生异常那样的记述错误，机器语言生成部108也对该命令列109a进行编译生成机器语言。

另外，若命令列109a的编译结束而获取部104获取指令“.enable_check”，则异常检测部105重新开始检测异常的处理。由此，在图35的例子中，通过异常检测部105检测命令列109b中的异常。

这样通过利用指令“.disable_check”、“.enable_check”，能够使异常检测部105检测异常的处理无效，或者使异常检测部105检测异常的处理有效。

此外，也可以代替像这样使用汇编语言的指令，而利用开发者给予信息处理装置100汇编的指示时的命令行自变量来抑制检测异常的功能。

图36是表示命令行自变量的一个例子的示意图。

在图36中，对指示信息处理装置100根据汇编语言的源程序109生成机器语言的可执行程序111(参照图32)的指令“gas”的自变量给予“-no_check”。命令行自变量的“-no_check”是在信息处理装置100对源程序109进行汇编时，使异常检测部105检测异常的功能无效的自变量。由此，能够防止在汇编时检测不必要的异常，能够提高程序开发的便利性。

接下来，对本实施方式的汇编程序112执行的处理进行说明。

图37是本实施方式的汇编程序112执行的处理的流程图。

首先，初始化部103将状态信息110初始化(步骤S41)。例如，初始化部103在数组“dataSizeVReg”、“dataTypeGReg”、以及“dataTypeVReg”的全部的元素储存“CLEAN”。另外，初始化部103在数组“readAccessGReg”、“readAccessVReg”、“writeAccessGReg”、以及“writeAccessVReg”的全部的元素储存“FALSE”。

接下来，获取部104从存储部102获取汇编语言的源程序109(步骤S42)。

接下来，异常检测部105判断检测异常的功能是否有效(步骤S43)。作为一个例子，异常检测部105在获取部104读入了指令“.disable_check”的情况下，判定为检测异常的功能无效。另外，异常检测部105在命令行自变量包含“-no_check”的情况下，也进行检测异常的功能无效的判定。

另一方面，异常检测部105在获取部104读入了指令“.enable_check”的情况下，或者在命令行自变量不包含“-no_check”的情况下，进行检测异常的功能有效的判定

这里，在判定为检测异常的功能无效(步骤S43：否定)的情况下移至步骤S48。

在步骤S48中，机器语言生成部108将获取部104获取的代码转换为机器语言。然后，机器语言生成部108生成包含该机器语言的可执行程序111，并将其写出到存储部102。

另一方面，在判定为检测异常的功能有效(步骤S43：肯定)的情况下移至步骤S44。

在步骤S44中，异常检测部105进行异常检测处理。后述该异常检测处理。

然后，异常检测部105判定是否检测到异常(步骤S45)。

这里，在判定为检测到异常的情况下(步骤S45：肯定)移至步骤S46。

在步骤S46中，错误输出部106输出错误，并结束处理。错误的输出方法并不特别限定。例如，错误输出部106将作为错误的原因的异常的种类输出到标准输出。

另一方面，在判定为未检测到异常的情况下(步骤S45：否定)移至步骤S47，状态更新部107更新状态信息110。

接下来，移至上述的步骤S48，机器语言生成部108生成机器语言的可执行程序111，并将其写出到存储部102。

之后，以与记述于汇编语言的源程序109的代码的行数对应地量，反复进行步骤S43～S48，并结束处理。

接下来，对步骤S44的异常检测处理进行说明。

图38是步骤S44的异常检测处理的流程图。

首先，异常检测部105检查是否有数据类型异常(步骤S51)。例如，异常检测部105通过根据获取部104获取的汇编语言的代码确定命令的种类，来确定该命令设为运算的对象的数据类型。并且，异常检测部105基于汇编语言的代码，确定该命令的源寄存器。

然后，异常检测部105确定数组“dataTypeGReg”、“dataTypeVReg”的各元素中与该源寄存器对应的元素。然后，异常检测部105判定确定出的元素表示的数据类型与命令设为运算的对象的数据类型是否一致，在不一致的情况下检测到数据类型异常。

接下来，异常检测部105检查是否有数据大小异常(步骤S52)。例如，异常检测部105基于获取部104获取的汇编语言的代码，确定该代码所包含的命令的源寄存器。并且，异常检测部105判定数组“dataSizeVReg”的各元素中与该源寄存器对应的元素表示的数据大小与命令的源寄存器所指定的数据大小是否一致。而且，在两者不一致的情况下异常检测部105检测到数据大小异常。

接下来，异常检测部105检查是否有W异常(步骤S53)。作为一个例子，异常检测部105基于获取部104获取的汇编语言的代码，确定该代码所包含的命令的源寄存器。而且，异常检测部105在数组“writeAccessGReg”、“writeAccessVReg”的各元素中与确定出的源寄存器对应的元素为“FALSE”的情况下检测到W异常。

接着，异常检测部105检查是否有R异常(步骤S54)。例如，异常检测部105基于获取部104获取的汇编语言的代码，确定该代码所包含的命令的目的寄存器。

在确定出的目的寄存器为通用寄存器的情况下，异常检测部105确定与该目的寄存器对应的数组“writeAccessGReg”和数组“readAccessGReg”各自的元素。并且，异常检测部105在确定出的数组“writeAccessGReg”的元素为“TRUE”，并且确定出的数组“readAccessGReg”的元素为“FALSE”的情况下检测到R异常。

此外，在目的寄存器为向量寄存器的情况下，异常检测部105也利用数组“writeAccessVReg”和数组“readAccessVReg”各自的元素检测R异常。

接下来，异常检测部105检查是否有src数据类型异常(步骤S55)。

例如，异常检测部105根据获取部104获取的汇编语言的代码确定命令的种类，判断该命令是否是以两个源寄存器的数据类型相同为前提的命令。而且，在判断为是以数据类型相同为前提的命令的情况下，异常检测部105基于获取的代码确定两个源寄存器。

在确定出的两个源寄存器为通用寄存器的情况下，异常检测部105判断与这些源寄存器的各个对应的数组“dataTypeGReg”的元素是否相同。而且，在判断为不相同的情况下，异常检测部105检测到src数据类型异常。此外，在源寄存器为向量寄存器的情况下，异常检测部105也利用“dataSizeVReg”检测src数据类型异常。

通过以上，结束异常检测处理。

根据上述的本实施方式，在对汇编语言的源程序109进行汇编时，异常检测部105基于状态信息110(图33)检测异常。因此，能够在由处理器90(参照图30)执行通过汇编得到的可执行程序111之前尽早地检测源程序109的记述错误，能够实现程序开发的效率化。

并且，由于能够在可执行程序111的执行前检测记述错误，所以在处理器90无用地执行有记述错误的可执行程序的时间减少，能够改善处理器90、存储器28等硬件资源的不必要的消耗。

并且，在步骤S44的异常检测处理中使用的状态信息111包含有用于检测“R异常”、“W异常”、“数据类型异常”、“数据大小异常”、以及“src数据类型异常”的各种数组。通过在图34的(a)、(b)的检测规则应用该数组的元素，异常检测部105能够检测上述的各种异常。因此，开发者能够根据检测到哪个种类的异常，确定汇编语言的源程序109中的具体的记述错误。

(第四实施方式)

在使用了JIT(Just In Time：即时)编译技术的程序中也可能产生在第一～第三实施方式进行了说明的“W异常”、“R异常”、“数据类型异常”、“数据大小异常”、以及“src数据类型异常”的各个。

JIT编译技术是根据在执行时决定的参数、处理内容、以及处理器的状况，生成合适的机器语言的命令列的技术。使用JIT编译技术生成的机器语言的命令列与AOT(AheadOf Time：)型的编译器生成的由能够通用地进行处理的机器语言的命令列构成的可执行程序相比处理高速。

因此，首先在与AOT编译技术进行比较的同时对该JIT编译技术进行说明。

图39是执行通过AOT编译技术、JIT编译技术生成的可执行程序的信息处理装置的硬件构成图。

该信息处理装置117是HPC用途的计算机或者PC(Personal Computer：个人计算机)等计算机，具备具有与图30所示的处理器相同的结构的处理器90和存储器28。

其中，处理器90是具备图30所示的各种电路21～25和运算用寄存器文件27的硬件。另外，存储器28是展开可执行程序的DRAM等易失性存储器。能够如以下那样通过使用AOT编译技术对源代码进行编译来生成该可执行程序。另外，在使用JIT编译技术的情况下，在可执行程序的执行中动态地生成机器语言的命令列。

图40的(a)是表示以利用AOT编译技术进行编译为前提的C++的伪源代码120的一个例子的示意图。

在AOT编译技术中，开发者根据C语言或者C++的语法记述源代码，GCC(GNUCompiler Collection：GNU编译器集合)等编译器将该源代码编译为机器语言的命令列。

在图40的(a)的例子中，在处理120a中将数组“Tbl”的各元素除以参数“q”。然后，在处理120b中，将数组“in”的元素除以数组“Tbl”的元素，并将其储存于数组“out”。

图40的(b)是表示声明了参数“q”和数组“in”、“out”的C++的伪源代码121的一个例子的示意图。

参数“q”是上述的处理120a中的除数，以下也称为输入参数。另外，数组“in”和数组“out”分别是处理120b中的输入数据和输出数据。这些数组“in”、“out”所储存的数据并不特别限定。这里作为储存1000000个由十六个像素数据构成的图像的二维数组而声明数组“in”和数组“out”。

图40的(c)是表示声明了数组“Tbl”的初始值的C++的伪源代码122的一个例子的示意图。

数组“Tbl”是储存量化像素数据的量化表的值的数组。这里，作为具有与各数组“in”、“out”对应的十六个元素的数组，而声明数组“Tbl”。然后，假定数组“Tbl”的各元素的初始值为2的幂。

图40的(a)～图40的(c)的源代码120～122全部由开发者根据C语言或者C++的语法进行记述，并通过编译器转换为汇编程序。

图41是利用AOT编译技术对上述的源代码120进行编译而得到的汇编程序124的伪代码的示意图。

在该汇编程序124与各处理120a、120b对应地生成有处理器90的指令集所包含的多个命令。

例如，由从mov命令到jmplt命令的六个命令实现处理120a，由从mov命令到jmplt命令的十个命令实现处理120b。此外，这里首先在通用寄存器x2保存输入参数“q”。

这里，对处理120b中的命令“div x2，x2，x1”进行考虑。该命令是相当于源代码120的处理10b中的“in[i]/Tbl[i]”的命令。除数的“Tbl[i]”在源代码120的处理120a除以输入参数“q”。上述的命令“div x2，x2，x1”是不管输入参数“q”的值如何均给予正确的除法结果的命令。因此，汇编程序124成为不管对于何种输入参数“q”均给予正确的结果的通用的代码。

然而，div命令那样的进行除法的命令是与其它的命令相比执行周期数较多的命令。因此，div命令是从执行开始到得到其结果为止的吞吐量较大，导致处理性能的降低的命令。虽然也根据处理器的种类，但div命令以外的数值运算命令的执行周期数为1～5，与此相对div命令的执行周期数有时达到80左右。并且，在深层学习、图像处理等中for循环的循环次数变得庞大，所以由于处于该for循环的内侧的div命令而吞吐量的降低变得更显著。

汇编器通过将这样的汇编程序124翻译为机器语言的命令列生成由机器语言构成的可执行程序。如LLVM那样，根据编译器的种类，有不管处理器的种类，而生成具有虚拟的指令集的面向处理器的汇编程序。该情况下，虽然也有将该汇编程序转换为面向个别的处理器的机器语言的命令列的情况，但若有div命令那样的除法命令则吞吐量降低的点相同。

图42是表示利用AOT编译技术得到的可执行程序的动作的示意图。

如图42所示，可执行程序125受理作为输入数据的数组“in”的各元素和输入参数“q”的输入。然后，如上述那样不管输入参数“q”、数组“in”的值的如何，而可执行程序125通过根据同一汇编程序124得到的机器语言的命令列进行处理，并将该处理的结果储存于数组“out”的各元素。

接下来，对以能够抑制吞吐量的降低的JIT编译技术为前提的程序进行说明。

图43是表示使用了JIT编译技术的C++的伪源代码126的一个例子的示意图。

该源代码126是通过开发者记述为其执行结果与图40的(a)的源代码120的执行结果相同的代码，具有处理126a和处理126b。其中，处理126a与源代码120的处理120a相同，是将数组“Tbl”的各元素除以参数“q”的处理。另外，处理126b是生成进行将数组“in”的元素除以数组“Tbl”的元素并将其储存于数组“out”的处理的机器语言的命令列的处理。

在该处理126b通过开发者记述有具有与作为命令的名称的助记符相同的函数名的“mov(x0，i)”等函数。函数“mov(x0，i)”可以说是与汇编语言的“mov(x0，#i)”对应的函数，是将表示“mov x0，#i”进行的处理的机器语言写入到存储器28的函数。此外，在汇编语言中不能够记述变量，如“mov(x0，#5)”、“mov(x0，#-128)”等那样在汇编语言中仅能够指定固定的值。在使用JIT编译技术的情况下，立即值能够使用变量i。这是JIT编译技术的优点之一。以下将像这样函数名与命令的助记符相同，并且将表示该命令进行的处理的机器语言写入到存储器的函数称为助记函数。

处理126b是将对i＝0～15执行in[i]/Tbl[i]的机器语言的命令列写入到存储器28的处理。在该例子中，开发者通过记述switch语句，根据作为除数的数组元素“Tbl[i]”的值使用不同的助记函数生成机器语言的命令列。

例如，在“Tbl[i]”的值为“1”的情况下，相对于“in[i]”的除数为“1”，所以不需要对“in[i]”进行任何处理。由此，该情况下，在“case 1”中不进行对储存“in[i]”的值的通用寄存器x1的值进行运算的机器语言的生成，仅直接在存储器28写入向out[i]储存值的机器语言。

另一方面，在“Tbl[i]”的值为“2”的情况下，在“case 2”中执行与shiftR命令的机器语言的生成对应的“shiftR(x1，x1，#1)”。该助记函数是在存储器28写入表示使通用寄存器x1的内容向右位移1位，并将其结果写入到寄存器x1的处理的机器语言的函数。由此，通过执行“shiftR(x1，x1，#1)”，能够在存储器28写入进行与将储存于通用寄存器x1的“in[i]”除以2等效的处理的机器语言。

另外，在“Tbl[i]”的值为“4”的情况下，在“case 4”中执行“shiftR(x1，x1，#2)”。由此，通用寄存器x1的内容向右位移2位，能够在存储器28写入进行与将储存于通用寄存器x1的“in[i]”除以4等效的处理的机器语言。

这样，在除数的“Tbl[i]”为2的幂值的情况下，执行与shiftR命令对应的助记函数。

而且，在“Tbl[i]”的值不是“1”、“2”、“4”那样的2的幂的情况下，在“default”中执行“div(x1，x1，x2)”。该助记函数是与div命令对应的函数，是在存储器28写入将使通用寄存器x1的内容除以通用寄存器x2的内容后的值写入到通用寄存器x1的机器语言的函数。

根据该源代码126，在“Tbl[i]”的值为“1”、“2”、“4”那样的2的幂的情况下，在存储器28写入等效于与div命令相比执行周期数较少的shiftR命令的机器语言或者不进行任何处理的机器语言。而且，仅在“Tbl[i]”的值不是“1”、“2”、“4”那样的2的幂的情况下在存储器写入与div命令等效的机器语言。

在JIT编译技术中，通过像这样根据“Tbl[i]”等参数的值写入最适合减少执行周期数的机器语言，与AOT编译技术相比能够使程序的执行速度高速化。

图44是表示在对源代码126进行编译而得到的可执行程序的执行中，处理126b在存储器28写入何种机器语言的命令列的示意图。此外，在执行该可执行程序时，对输入参数“q”给予“8”。另外，在图44中，也一并标注对该机器语言的命令列进行反汇编的汇编程序127的伪代码。

如图44所示，在q＝8的情况下，数组“Tbl”的各元素从前端开始依次为“1”、“2”、“4”。由此，在处理126b的for循环执行时，在存储器28内配置与i＝0(case 1)、i＝1(case2)、i＝2(case 4)的各情况对应的shiftR函数和store函数分别生成的机器语言128。而且，对该机器语言128进行反汇编后的代码成为汇编程序127中的代码127a、127b、127c。

图45是表示利用JIT编译技术在执行时生成在执行时调用的函数的可执行程序的动作的示意图。这里，对编译使用了JIT编译技术的源代码126得到的可执行程序130的动作进行说明。

如图45所示，可执行程序130首先受理输入参数“q”的输入(步骤P10)。接下来，可执行程序130根据该输入参数“q”的值，生成处理变得高速的机器语言128(步骤P11)。在上述的图44的例子中，生成适合于“Tbl[i]”的值的机器语言128。

接着，可执行程序130受理作为输入数据的数组“in”的各元素的输入(步骤P12)，并将处理的结果储存于数组“out”的各元素(步骤P13)。

此时，在机器语言128中不包含吞吐量较慢的div命令，所以与汇编程序124所对应的可执行程序相比能够进行高速的处理。并且，通过像这样根据输入参数“q”的值生成适当的机器语言128，在JIT编译技术中与AOT编译技术相比能够使程序的执行速度高速化。

然而，在使用这样的JIT编译技术的情况下，开发者自己记述图43所示那样的源代码126。在该源代码126中调用助记函数mov、助记函数load等的代码与汇编语言的语法类似。因此，在记述源代码126等应用程序用的源代码时，有可能产生与图8～图13所示的第一例～第五例类似的记述错误。以下对这样的记述错误进行说明。

·第一例

图46是用于说明第一例的记述错误的应用程序用的C++的源代码的示意图。

在该源代码140中，通过代码T40的语句“vmov(v15.s，3)；”调用助记函数vmov。该助记函数vmov的第一自变量的“v15.s”是与汇编语言的v15.s对应的格式。若执行该助记函数vmov，则执行在存储器28写入用于执行与汇编语言的代码“vmov v15.s，3”相同的处理的机器语言的命令列的代码。另外，该代码“vmov v15.s，3”是将在数据大小为单字“s”的四个元素分别储存了整数的立即值“3”的向量数据写入到向量寄存器v15的代码。

另一方面，代码T41的语句“float_multiply(vi.s，vi.s，v15.s)；”是用于调用助记函数float_multiply的语句。若执行该助记函数float_multiply，则执行将用于执行与汇编语言的代码“float_multiply(vi.s，vi.s，v15.s)；”相同的处理的机器语言的命令列写入到存储器28的代码。此外，在像这样在使用了计数器变量“i”的for循环的内侧记述了“vi.s”等的情况下，在“vi”的“i”的部分代入有计数器变量“i”的值“0”、“1”、“2”、…。另外，该float_multiply命令是将在第二操作数和第三操作数分别指定的向量寄存器所储存的浮点小数彼此相乘，并将其结果写入到第一操作数的向量寄存器的命令。

这样float_multiply命令设为运算的对象的数据类型为浮点小数，所以在作为float_multiply命令的源寄存器的向量寄存器v15必须写入浮点小数。但是，在该例子中，在代码T40中在向量寄存器v15写入整数，所以该编码错误。

·第二例

图47是用于说明第二例的记述错误的应用程序用的C++的源代码的示意图。

在该源代码141中，通过代码T42的语句“vmov(v15.b，3)；”调用助记函数vmov。若执行该助记函数vmov，则执行在存储器28写入用于执行与汇编语言的代码“vmov v15.b，3”相同的处理的机器语言的命令列的代码。另外，该代码“vmov v15.b，3”是在向量寄存器v15写入分别在数据大小为字节“b”的十六个元素储存了整数的立即值“3”的向量数据的代码。

另一方面，在代码T43中，执行用于调用助记函数multpily的语句“multiply(vi.s，vi.s，v15.s)；”。若执行该助记函数multiply，则执行在存储器28写入用于执行与汇编语言的代码“multiply vi.s，vi.s，v15.s”相同的处理的机器语言的命令列的代码。该代码“multiply vi.s，vi.s，v15.s”是将向量寄存器vi、v15各自所储存的数据大小为单字“s”的元素彼此相乘，并将其结果写入到向量寄存器vi的对应的元素的代码。据此，开发者意图在代码T43中进行数据大小为单字“s”的数据彼此的运算。

但是，在向量寄存器v15通过上述的代码T42写入数据大小为字节“b”的元素，所以若执行代码T43则得到与开发者的意图不同的结果。

这样，先行命令的目的寄存器的数据大小与将该目的寄存器作为源寄存器的后续命令的该源寄存器的数据大小不同的记述为错误。

·第三例

图48是用于说明第三例和第四例的记述错误的应用程序用的C++的源代码的示意图。

在该源代码142中，在代码T44中，分别对“i”的值为0～7的情况执行语句“vload(vi.s，inAddr)；”。该语句是用于调用与vload命令对应的助记函数vload的语句。若执行该助记函数vload，则执行在存储器写入用于执行与“vload vi.s，inAddr”这样的命令相同的处理的机器语言的命令列的代码。此外，命令“vload vi.s，inAddr”是将地址为“inAddr”的存储器的数据分别写入到向量寄存器vi的四个元素的命令。

另一方面，在代码T45中，分别对“i”的值为0～9的情况执行语句“multiply(vi.s，vi.s，v15.s)；”。但是，i＝8、i＝9时的代码T45的第二自变量亦即向量寄存器v8、v9在上述的代码T44中未写入数据，在代码T45以前未被用作目的寄存器。由此，不明确在向量寄存器v8、v9写入何种数据，而向量寄存器v8、v9的数据不确定。

在这样的状态下执行代码T45，写入到目的寄存器的向量寄存器v8、v9的数据也变得不确定。由此，像这样将没有使用为目的寄存器的情况的寄存器指定为源寄存器是错误的。

·第四例

继续参照图48的源代码142对第四例的记述错误进行说明。

在该源代码142的代码T46中，执行进行生成与“multiply v0.s，v1.s，v15.s”这样的命令等效的机器语言的处理的语句“multiply(v0.s，v1.s，v15.s)；”。该命令是将向量寄存器v1、v15各自的元素彼此相乘并将其结果写入到向量寄存器v0的命令。

虽然在向量寄存器v0写入有代码T45的结果，但一次也未使用该结果，而在代码T46中覆盖向量寄存器v0的内容。这样一来，在向量寄存器v0写入运算结果的代码T45的存在意义不明，怀疑代码T45或者代码T46中的寄存器的指定错误。

因此，像这样对于已用作目的寄存器的寄存器，在之后不用作源寄存器，而再次指定为目的寄存器是错误的。

·第五例

图49是用于说明第五例的记述错误的应用程序用的C++的源代码的示意图。

在该源代码143中，在代码T47中执行用于调用助记函数vmov的语句“vmov(v15.s，7)；”。这样在第二自变量指定了整数的情况下，助记函数vmov成为生成进行与分别在向量寄存器v15的四个元素写入整数的立即值“7”的命令“vmov v15.s，7”等效的处理的机器语言的函数。

另外，在代码T48中，执行在第二自变量指定了“3.14”的助记函数vmov。该情况下，代码T48中的助记函数vmov成为生成进行与分别在向量寄存器v14的四个元素写入以浮点小数表示的“3.14”的命令“vmov v14.s，3.14”等效的处理的机器语言的函数。

另一方面，在代码T49中，调用进行整数彼此的乘法运算的助记函数multiply。与该助记函数multiply对应的multiply命令是以两个源操作数各自的数据类型相同为前提的命令。

但是，在该例子中，写入到向量寄存器v15的数据的类型为整数，与此相对写入到向量寄存器v14的数据的类型为浮点小数，两者不相同。

由此，在像这样写入到两个源寄存器的数据的数据类型不同的情况下也成为编码的错误。

图50是总结上述的第一例～第五例的记述错误的图。

如图50所示，与第一～第三实施方式相同，在本实施方式中也定义分别与第一例～第五例对应的异常。这些异常中，“数据类型异常”和“数据大小异常”分别与第一例和第二例的记述错误对应。另外，“W异常”和“R异常”分别与第三例和第四例的记述错误对应。而且“src数据类型异常”与第五例的记述错误对应。

接下来，对能够检测这些异常的信息处理程序进行说明。

在本实施方式中，与第一～第三实施方式相同，使用存储了通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)各自的状态的状态信息。

图51是表示示出本实施方式的状态信息的C++的伪源代码的示意图。

该状态信息145中的代码T60～T67分别与图33中的状态信息110中的代码T20～T27相同，所以这里仅对其概略进行说明。

如参照图33进行了说明的那样，代码T61是声明储存向量寄存器vn(n＝0、1、…31)的数据大小的数组“dataSizeVReg”的代码。

另外，代码T63是声明储存通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)各自的数据类型的数组“dataTypeGReg”、“dataTypeVReg”的代码。

而且，代码T65是声明表示通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)的各个是否已被用作源寄存器的数组“readAccessGReg”、“readAccessVReg”的代码。

并且，代码T67是声明表示通用寄存器xn(n＝0、1、…31)和向量寄存器vn(n＝0、1、…31)的各个是否已被用作目的寄存器的数组“writeAccessGReg”、“writeAccessVReg”的代码。

图52的(a)、(b)是用于说明使用图51的状态信息检测异常时的检测规则的示意图。

其中，图52的(a)是示意性地表示通用寄存器xn(n＝0、1、2…31)被指定为助记函数的自变量的情况下的检测规则的图。另外，图52的(b)是示意性地表示向量寄存器vn(n＝0、1、2…31)被指定为助记函数的自变量的情况下的检测规则的图。

图52的(a)、(b)的检测规则与图34的(a)、(b)中的规则相同，所以这里仅对其概略进行说明。

例如，如图52的(a)所示，在与源寄存器对应的数组“writeAccessGReg”的元素为“FALSE”时产生W异常。

另外，在与目的寄存器对应的数组“writeAccessGReg”的元素为“TRUE”，并且与目的寄存器对应的数组“readAccessGReg”的元素为“FALSE”的情况下检测到R异常。

并且，在与源寄存器对应的数组“dataTypeGReg”的元素与命令设为运算的对象的数据类型不同的情况下检测到数据类型异常。

而且，在与第一个和第二个各自的源寄存器对应的数组“dataTypeGReg”的元素彼此不同的情况下检测到src数据类型异常。

另外，如图52的(b)所示，向量寄存器被指定为助记函数的自变量的情况下，也与通用寄存器的情况相同地检测“W异常”、“R异常”、“数据类型异常”、以及“src数据类型异常”。

并且，在向量寄存器的情况下，除了这些异常之外还检测“数据大小异常”。在与被指定为助记函数的自变量的源寄存器对应的数组“dataSizeVReg”的元素与在该自变量指定的数据大小不同的情况下检测到该“数据大小异常”。

接下来，对本实施方式的助记函数进行说明。

在与开发者记述的应用程序用的程序不同的信息处理程序中定义本实施方式的助记函数。在该定义中，使用以下那样的各种类型。

图53的(a)～(d)和图54的(a)～(d)是定义助记函数所使用的各种类型的C++的伪源代码的示意图。

其中，图53的(a)是定义Operand类型的源代码的例子。

Operand类型是具有“type”和“value”作为成员变量的类。其中，在“type”储存有寄存器、立即值等操作数的种类。而且，在“value”储存有立即值、寄存器的索引等数值。

图53的(b)是定义AddrReg类型的源代码的例子。

AddrReg类型是表示地址寄存器的类。该类的成员变量是储存保持地址的基值的寄存器的索引的“regIndex”、和储存地址偏移值亦即立即值的“imm_value”。此外，“imm_value”的初始值为0。

图53的(c)是定义Imm类型的源代码的例子。

Imm类型是表示有符号整数立即值的类。该类的成员变量是储存有符号整数立即值的“imm_value”。

图53的(d)是定义UnsignedImm类型的源代码的例子。

UnsignedImm类型是表示无符号整数立即值的类。该类的成员变量是储存无符号整数立即值的“imm_value”。

另外，图54的(a)～(d)分别是定义VRegB类型、VRegH类型、VRegS类型、以及VRegD类型的源代码的例子。这些类型是表示储存于向量寄存器的向量数据的元素的数据大小的类。例如，VRegB类型和VRegH类型分别与字节和半字对应。而且，VRegS类型和VRegD类型分别与单字和双字对应。此外，这些类的成员变量均为表示数据大小的无符号整数的“regIndex”。

接下来，对本实施方式的助记函数的定义进行说明。

与指令集所包含的全部的命令对应地定义助记函数。例如，若在指令集有multiply命令、add命令、load命令、以及store命令等，则这些命令对应地定义助记函数multiply、助记函数add、助记函数load、以及助记函数store。以下，对这些助记函数的一部分进行说明。

图55以及图56是记述了定义助记函数multiply的C++的源代码的源文件150的示意图。

如图55以及图56所示，在该源文件150通过开发者记述有代码T70～T83。

其中，代码T70是声明助记函数multiply接受的自变量“dst”、“src0”、以及“src1”的代码。这些自变量中，“dst”表示multiply命令的第一操作数亦即目的寄存器。另外，“src0”和“src1”分别表示multiply命令的第二操作数和第三操作数的源寄存器。

另一方面，代码T71的语句“nm＝“multiply_VRegB”；”是将识别命令和其操作数的数据大小的字符串“multiply_VRegB”代入到变量nm的语句。这里，通过字符串“multiply_VRegB”中的“multiply”，唯一地识别助记函数multiply与multiply命令对应。另外，通过字符串“multiply_VRegB”中的“VRegB”，唯一地识别源寄存器与目的寄存器的数据大小为字节“b”。

另外，代码T72是声明Operand类型的变量“op0”、“op1”、以及“op2”，并在各个成员变量代入规定的值的代码。这里，变量“op0”、“op1”、以及“op2”分别与“dst”、“src0”、以及“src1”对应。

该情况下，变量“op0”与目的寄存器对应。因此，在变量“op0”的成员变量“type”代入有“REGISTER”，在成员变量“value”代入有表示目的寄存器的索引的“dst.regIndex”。

同样地，变量“op1”与第一个源寄存器对应，所以在其成员变量“type”代入有“REGISTER”，在“value”代入有表示第一个源寄存器的索引的“src0.regIndex”。

并且，变量“op2”与第二个源寄存器对应，所以在其成员变量“type”代入有“REGISTER”，在“value”代入有表示第二个源寄存器的索引的“src1.regIndex”。

而且，代码T73是在数组“oplist”代入上述的变量“op0”、“op1”、以及“op2”的语句。

另一方面，代码T74～T78是根据上述的图52的(a)、(b)的检测规则检测异常的代码。例如，代码T74和代码T75分别是检测“R异常”和“W异常”的代码。另外，代码T76和代码T77分别是检测“数据大小异常”和“数据类型异常”的代码。而且，代码T78是检测“src数据类型异常”的代码。

此外，在这些代码T74～T78中，也包含在检测到异常的情况下输出错误的语句。例如，在代码T74中检测到R异常的情况下，作为错误向标准输出输出“Invalid registeruse.Data on destination register is not used.”这样的字符串。

而且，在上述的代码T74～T78中未检测到异常的情况下执行代码T79～T83。

其中，代码T79是调用MachineCodeEmitter函数，并利用函数write将该MachineCodeEmitter函数的返回值写入到存储器28的代码。MachineCodeEmitter是接受函数变量“nm”和变量“oplist”作为自变量，并生成表示对由变量“oplist”表示的操作数进行由变量“nm”表示的命令的处理的机器语言的函数。

此外，MachineCodeEmitter函数是与处理器90的汇编程序一起制成的动作完成验证的函数。

而且，代码T80～T83是更新状态信息145的代码。

其中，代码T80是更新数组“writeAccessVReg”的元素的代码。在该例子中，通过执行multiply命令已经使用目的寄存器，所以在与该目的寄存器对应的数组“writeAccessVReg”的元素储存“TRUE”。

另外，代码T81是更新数组“dataSizeVReg”的元素的代码。在该例子中，在代码T70中，助记函数multiply的第一自变量的类型为“VRegB”，确定multiply命令的目的寄存器的数据大小为字节“b”。由此，在代码T81中，在与该目的寄存器对应的数组“dataSizeVReg”的元素储存表示字节“b”的“sizeB”。

而且，代码T82是更新数组“dataTypeVReg”的元素的代码。在multiply命令中，在目的寄存器写入与两个源寄存器相同的数据类型的数据。由此，在该例子中，在与目的寄存器对应的数组“dataTypeVReg”的元素储存第一个源寄存器的数据类型。

另外，代码T83是更新数组“readAccessVReg”的元素的代码。若执行助记函数multiply，则在代码T70指定的两个自变量“src0”、“src1”表示的两个源寄存器使用完毕。因此，在代码T83中，在与这两个源寄存器对应的数组“readAccessVReg”各自的元素储存表示已被用作源寄存器的“TRUE”。

如以上那样，在该例子中，能够通过代码T74～T78检测“R异常”、“W异常”、“数据大小异常”、“数据类型异常”、以及“src数据类型异常”。

此外，如上述那样，与指令集所包含的全部的命令对应地定义助记函数。接下来，对助记函数multiply以外的助记函数的源代码的例子进行说明。

图57～图69是示意性地表示定义上述的源文件150所记述的各种助记函数的C++的伪源代码的图。

例如，图57以及图58是记述了定义助记函数float_multiply的C++的源代码的源文件150的示意图。另外，图59～图69是记述了定义分别与vload命令、vadd命令、vstore命令、cvtssBtoH命令、vmov命令、以及cvtFloatSigned命令对应的助记函数的源代码的源文件150的示意图。

此外，图65的助记函数cvtssBtoH是与cvtssBtoH命令对应的助记函数。该cvtssBtoH命令是将储存于源寄存器的MSB(Most Significant Bit：最高有效位)侧的八个有符号8位数据转换为有符号16位数据并储存于目的寄存器的命令。

而且，图69的助记函数cvtFloatSigned是与cvtFloatSigned命令对应的助记函数。该cvtFloatSigned命令是将储存于源寄存器的32位的浮点小数转换为32位的有符号整数并储存于目的寄存器的命令。

另外，在各图57～图69中，对与在图55和图56进行了说明的代码同种的代码附加与这些图中的附图标记相同的附图标记，并省略其说明。

虽然根据命令而产生的异常有不同，但在图57～图69所示的各种助记函数中也能够通过代码T74～T78检测异常。

此外，根据助记函数的种类，有若能够使像这样检测异常的功能无效则便利的情况。例如，在可执行程序的执行之前有对通用寄存器x0进行清零的xor(x0，x0，x0)这样的助记函数。该函数是不管在源寄存器是否写入数据而对通用寄存器x0进行清零的函数，所以若检测到W异常而不执行则不能够将通用寄存器x0清零。

在该情况下，如以下那样抑制助记函数检测异常的功能即可。

图70的(a)、(b)是示意性地表示抑制检测异常的功能的方法的图。

在该例子中，开发者分别在源文件150记述如图70的(a)那样具备检测异常的功能的助记函数xor、和如图70的(b)那样不具备该功能的助记函数xor_without_check。

其中，在图70的(a)的助记函数xor中，通过上述的代码T74～T78进行异常的检查，通过代码T80～T83进行状态信息145的更新。另一方面，在图70的(b)的助记函数xor_without_check中没有代码T74～T78、T80～T83，不进行异常的检查和状态信息145的更新。

此外，无论在助记函数xor和助记函数xor_without_check的哪一个中，均在源文件150记述在存储器28写入xor命令的机器语言的代码T79。

而且，在想要使用检测异常的功能的情况下，开发者在应用程序用的源文件记述调用图60的(a)的助记函数xor的代码。

另一方面，在不想使用检测异常的功能的情况下，开发者在应用程序的源文件记述调用图60的(b)的助记函数xor_without_check的代码即可。

此外，也可以不像这样准备两种助记函数，而能够利用一个助记函数抑制检测异常的功能。

图71是这样能够抑制检测异常的功能的助记函数的C++的伪源代码的示意图。

如图71所示，在该例子中，在助记函数xor的自变量追加指定是否使检测异常的功能有效的自变量“no_check”。

而且，在自变量“no_check”的值为“0”的情况下，通过上述的代码T74～T78进行异常的检查，并通过代码T80～T83进行状态信息145的更新。另一方面，在自变量“no_check”的值为“0”以外的情况下，不进行异常的检查和状态信息的更新。

由此，通过在应用程序用的源文件中调用助记函数xor时由开发者指定自变量“no_check”的值，能够简单地使检测异常的功能有效或者无效。

另外，也可以如以下那样利用全局变量抑制检测异常的功能。

图72的(a)是在助记函数xor的内部记述了用于抑制检测异常的功能的全局变量“g_check_on”时的源文件150的示意图。

在该例子中，开发者在源文件150记述判定全局变量“g_check_on”的值是否为“1”的if语句。而且，开发者在该if语句的内部记述进行异常的检查的代码T74～T78、进行状态信息145的更新的代码T80～T83。

图72的(b)是示意性地表示利用了该助记函数xor的应用程序用的源文件152的C++的伪源代码的图。

这里，假定开发者在源文件152记述了调用多个助记函数xor的代码152a的情况。而且，假设开发者想要使这些助记函数xor检测异常的功能无效。该情况下，开发者在代码152a之前的位置记述disable_check函数。disable_check函数是将全局变量“g_check_on”的值设置为“0”的函数。

由此，能够不执行代码152a的助记函数xor(x0，x0，x0)和助记函数xor(x1，x1，x1)各自的代码T74～T78，而使这些助记函数检测异常的功能无效。

另外，在想要在该代码152a之后的代码152b使检测异常的功能有效的情况下，开发者在代码152a之后的位置记述enable_check函数即可。enable_check函数是将全局变量“g_check_on”的值设置为“1”的函数。

由此，执行代码152a的助记函数xor(x0，x0，x0)和助记函数xor(x1，x1，x1)各自的代码T74～T78，能够使这些助记函数检测异常的功能有效。

这样能够通过利用disable_check函数和enable_check函数，使助记函数检测异常的处理无效，或者使助记函数检测异常的处理有效。此外，例如由开发者预先在源文件150记述disable_check函数和enable_check函数各自的定义即可。

接下来，对图55～图69的代码T79中的MachineCodeEmitter函数进行说明。

图73是表示记述了MachineCodeEmitter函数的C++的伪源代码的源文件151的一个例子的示意图。该源文件151也可以是汇编程序自身的源文件的一部分。

在该例子中，通过代码T90～T93实现MachineCodeEmitter函数的功能。其中，代码T90是分别将变量“mnemonic”和变量“op0”、“op1”、“op2”声明为32位的无符号整数的语句。

另外，代码T91是将MachineCodeEmitter函数作为自变量接受的变量“nm”的内容所对应的操作码代入到变量“mnemonic”的代码。例如，在根据变量“nm”确定的助记符为“mov”的情况下，在变量“mnemonic”代入mov命令的操作码“0x01000000”。

而且，代码T92是通过根据变量“nm”的内容对各变量“op0”、“op1”、“op2”进行位操作，使这些变量位于根据命令的规格决定的位位置的代码。例如，在mov命令的情况下，第一操作数位于32位中的17～24位，第二操作数位于8～16位。因此，在mov命令的情况下，通过执行语句“op0＝oplist[0]<<16；”，使变量“op0”的位串位于32位中的17～24位。另一方面，变量“op1”通过执行语句“op1＝oplist[1]<<8；”，使“op1”的位串位于32位的第8～16位。此外，mov命令不取第三操作数，所以通过语句“op2＝0；”使变量“op2”为“0”。

并且，代码T93是生成从高位位开始依次连结各变量“mnemonic”、“op0”、“op1”、“op2”的各个的位串，并将其作为返回值返回的语句。该位串是表示根据变量“nm”确定的命令对根据变量“oplist”确定的操作数进行的处理的机器语言。

这样，MachineCodeEmitter函数是生成表示对由自变量“nm”表示的命令对由自变量“oplist”表示的操作数进行的处理的机器语言的函数。

在开发处理器90时，也开发用于生成在该处理器90进行动作的机器语言的可执行程序的工具组。在该工具组包含有用于将以C语言或者C++语言记述的源文件转换为汇编语言的编译器、用于将汇编语言转换为机器语言的汇编程序。作为这样的工具组，例如有LLVM。MachineCodeEmitter函数是内置于LLVM的汇编程序的函数，在开发汇编程序时验证其动作并提供。因此，在本实施方式中，不需要进行助记函数是否生成正确的机器语言这样的动作验证，能够实现开发者的负担减少。

开发者通过利用如上述那样定义了助记函数的源文件150，能够开发在处理器执行的各种应用程序。因此，以下对该应用程序的开发环境进行说明。

图74是表示利用了定义助记函数的源文件150的开发环境的示意图。

在该例子中，开发者例如使用C++制成应用程序用的源文件152。该源文件152是以使用JIT编译技术的功能为前提的文件，除了C++的库函数之外，还包含调用位于源文件150的助记函数的记述。

而且，在开发者的指示之下，编译器、汇编程序、以及连接程序的程序组153进行构建。在该构建时，程序组153所包含的编译器编译源文件152。

此时，编译器读入各源文件150、151、152并输出汇编语言的中间语言文件。这些源文件中，源文件151是记述了上述的MachineCodeEmitter函数的源文件。然后，汇编程序将该中间语言文件转换为机器语言的命令列生成对象文件。

之后，连接程序通过将对象文件与各种库连接，生成能够在处理器90执行的二进制格式的可执行程序154。

此外，在隐藏机器语言的生成规则那样的处理器中，也有虽然未公开汇编程序的源文件，但能够得到执行库文件的情况。在该情况下，代替源文件151而使用已经预先将机器语言生成函数的功能转换为机器语言的命令列的执行库文件151a作为输入，通过将其连接来生成执行库文件151a即可。

通过以上，能够根据应用程序用的源文件152生成可执行程序154。

在本实施方式中，如图55～图69所示，在定义各助记函数的源文件150记述根据图52的(a)、(b)的检测规则检测异常的代码T74～T78。因此，若在应用程序用的源文件152有符合图52的(a)、(b)的检测规则的记述错误，则在可执行程序154的执行时输出错误。由此，开发者能够注意在源文件152有记述错误，而开发者容易进行源文件152的调试。

接下来，对执行该可执行程序154时的信息处理装置117的动作进行说明。

图75是在用于得到可执行程序154的应用程序用的源文件152记述的C++的伪源代码的示意图。

如图75所示，在该例子中，假定在源文件152记述分别与mov命令、load命令、add命令、以及store命令对应的助记函数的情况。

图76是表示执行对该源文件152进行编译而得到的可执行程序154时的信息处理装置117的动作的流程图。

首先，信息处理装置117将状态信息145(参照图51)初始化(步骤S61)。

如，信息处理装置117在数组“dataSizeVReg”、“dataTypeGReg”、以及“dataTypeVReg”的全部的元素储存“CLEAN”。并且，信息处理装置117在数组“readAccessGReg”、“readAccessVReg”、“writeAccessGReg”、以及“writeAccessVReg”的全部的元素储存“FALSE”。

接下来，信息处理装置117进行记述于可执行程序154的助记函数的执行处理(步骤S62)。对图75的可执行程序154所记述的多个助记函数的每一个进行该处理。

例如，若进行在图75的代码T85记述的助记函数load(v2.b,x0)的执行处理，则在该助记函数load(v2.b，x0)的内部调用MachineCodeEmitter函数。然后，该MachineCodeEmitter函数生成相当于汇编语言的代码“load v2.b，x0”的机器语言128(参照图45)，并将其写入到存储器28。

接下来，信息处理装置117调用在步骤S62生成的机器语言128(步骤S63)，并执行该机器语言(步骤S64)。

通过以上，结束执行可执行程序154时的信息处理装置117的处理。

接下来，对上述的步骤S62的助记函数的执行处理进行说明。

图77是进行助记函数的执行处理时的信息处理装置117的功能构成图。

如图77所示，信息处理装置117具备控制部171和存储部172。

其中，存储部172是通过存储器28实现的功能模块，存储上述的状态信息145。

另一方面，控制部171具有异常检测部175、错误输出部176、状态更新部177、机器语言生成部178、以及写入部179。

其中，异常检测部175是通过图55～图69的代码T74～T78实现的处理部，基于状态信息145检测在执行助记函数时产生的异常。

例如，考虑进行在图75的代码T85记述的助记函数vload(v2.b，x0)的执行处理的情况。该情况下，在图59的代码T74中，基于作为状态信息145的一部分的数组writeAccessVReg[dst.regIndex]和数组readAccessVReg[dst.regIndex]检测R异常。此外，在变量“dst”储存有助记函数vload(v2.b，x0)的第一自变量的“v2.b”。

并且，该情况下，在图59的代码T75中，基于组我诶状态信息145的一部分的数组writeAccessVReg[addr.regIndex]检测W异常。此外，在变量“addr”储存有助记函数vload(v2.b，x0)的第二自变量的“x0”。

另一方面，错误输出部176是在异常检测部175检测到异常时输出错误的处理部。在本实施方式中，通过记述于图55～图69的各代码T74～T78的的throw语句实现错误输出部176。在进行记述在图75的代码T85的助记函数vload(v2.b，x0)的执行处理的例子中，通过图59的代码T74中的throw语句输出错误。如图59所示，该错误的内容是““Invalidregister use.Data on destination register is not used.””这样的字符串。另外，在执行了图59的代码T75的情况下，输出““Invalid register use.No data written onsource register.””这样的字符串作为错误。

而且，状态更新部177是在异常检测部175未检测到异常时更新状态信息145的内容的处理部。通过图55～图69的代码T80～T83实现该状态更新部177的功能。

并且，机器语言生成部178是通过图55～图69的代码T79中的MachineCodeEmitter函数实现的处理部。如上述那样，MachineCodeEmitter函数是生成表示与助记函数对应的命令对操作数进行的处理的机器语言128的函数。

而且，写入部179是通过图55～图69的代码T79中的write函数实现的处理部，是将机器语言生成部178生成的机器语言的命令列写入到存储器28的处理部。

接下来，对图77所示的信息处理装置117的各部执行的信息处理方法进行说明。

图78是本实施方式的信息处理方法的流程图。

首先，异常检测部175判断检测异常的功能是否有效(步骤S71)。例如，异常检测部175在图71的自变量“no_check”的值为“0”的情况下判断为该功能有效，在自变量“no_check”的值为“0”以外的情况下判断为该功能无效。

另外，开发者在源文件150记述图72的(b)的函数disable_check()的情况下，异常检测部175根据全局变量“g_check_on”的值判断检测异常的功能是否有效。例如，异常检测部175在全局变量“g_check_on”的值为“1”的情况下判断为该功能有效，在全局变量“g_check_on”的值为“1”以外的情况下判断为该功能无效。

这里，在判定为检测异常的功能无效(步骤S71：否定)的情况下移至步骤S76。

在步骤S76中，机器语言生成部178生成机器语言128。例如，考虑执行记述于图75的代码T85的助记函数vload(v2.b，x0)的情况。该情况下，机器语言生成部178生成与助记函数vload(v2.b、x0)对应的汇编语言的命令“vload v2.b，x0”对操作数的“v2.b”、“x0”进行的处理的机器语言128。

然后，写入部179将机器语言128写入到存储器28(步骤S77)。

另一方面，在判定为检测异常的功能有效(步骤S71：肯定)的情况下移至步骤S72。

在步骤S72中，异常检测部175进行异常检测处理。后述该异常检测处理。

然后，判定异常检测部175是否检测到异常(步骤S73)。

这里，在判定为检测到异常的情况下(步骤S73：肯定)移至步骤S74。

在步骤S74中，错误输出部176输出错误，并结束处理。

另一方面，在判定为未检测到异常的情况下(步骤S73：否定)移至步骤S75，状态更新部177更新状态信息145。

之后，执行上述的步骤S76和步骤S77，并结束处理。

接下来，对步骤S72的异常检测处理进行说明。

图79是步骤S72的异常检测处理的流程图。

基于图52的(a)，(b)的检测规则，如以下那样由异常检测部175执行该异常检测处理。

首先，异常检测部175检查是否有数据类型异常(步骤S81)。通过执行图55～图69的代码T77来进行该检查。如代码T77所记述的那样，异常检测部175判断与助记函数对应的命令设为运算的对象的数据类型与实际写入到助记函数的自变量的源寄存器的数据类型是否不同。

例如，在图58的代码T77中，判断实际写入到第一个源寄存器的数据类型“dataTypeVReg[src0.regIndex]”与float_multiply命令设为运算的对象的数据类型“typeFloat”是否不同。另外，在该代码T77中，也判断写入到第二个源寄存器的数据的数据类型“dataTypeVReg[src1.regIndex]”与float_multiply命令设为运算的对象的数据类型“typeFloat”是否不同。

而且，在命令设为运算的对象的数据类型与实际写入到源寄存器的数据的数据类型不同的情况下，异常检测部175检测到数据类型异常。

接下来，异常检测部175检查是否有数据大小异常(步骤S82)。通过执行图55～图69的代码T76来进行该检查。如代码T76所记述的那样，异常检测部175判断实际写入到助记函数的自变量的源寄存器的数据的数据大小与在该自变量指定的数据大小是否不同。

例如，在图57的代码T76中，判断写入第一个源寄存器的数据的数据大小“dataSizeVReg[src0.regIndex]”与在自变量指定的数据大小“sizeS”是否不同。另外，在该代码T76中，也判断写入第二个源寄存器的数据的数据大小“dataSizeVReg[src1.regIndex]”与在自变量指定的数据大小“sizeS”是否不同。

而且，在实际写入到源寄存器的数据的数据大小与在自变量指定的数据大小不同的情况下，异常检测部175检测到数据大小异常。

接下来，异常检测部175检查是否有W异常(步骤S83)。通过执行图55～图69的代码T75来进行该检查。如代码T75所记述的那样，异常检测部105在数组“writeAccessGReg”、“writeAccessVReg”的各元素中，与在助记函数的自变量指定的源寄存器对应的元素为“FALSE”的情况下检测到W异常。

例如，在图57的代码T75中，判断是否与第一个源寄存器对应的“writeAccessVReg[src0.regIndex]”不为“TRUE”。同样地，在该代码T75中，也判断是否与第二个源寄存器对应的“writeAccessVReg[src1.regIndex]”不为“TRUE”。

而且，在“writeAccessVReg[src0.regIndex]”不为“TRUE”的情况下，或者在“writeAccessVReg[src1.regIndex]”不为“TRUE”的情况下，异常检测部105检测到W异常。

接着，异常检测部175检查是否有R异常(步骤S84)。通过执行图55～图69的代码T74来进行该检查。如代码T74所记述的那样，在助记函数的自变量指定的寄存器为向量寄存器的情况下，异常检测部175使用数组“writeAccessVReg”和数组“readAccessVReg”进行检查。例如，异常检测部175使用这些数组“writeAccessVReg”、“readAccessVReg”的各元素中，与在助记函数的自变量指定的目的寄存器对应的元素。而且，异常检测部175在该数组“writeAccessVReg”的元素为“TRUE”，并且数组“readAccessVReg”的元素为“FALSE”的情况下检测到R异常。

例如，在图57的代码T74中，在“writeAccessVReg[dst.regIndex]”为“TRUE”，并且“readAccessVReg[dst.regIndex]”不为“TRUE”的情况下，异常检测部175检测到R异常。

此外，在目的寄存器为通用寄存器的情况下，异常检测部175也利用数组“writeAccessGReg”和数组“readAccessGReg”的各个元素检测R异常。

接下来，异常检测部175检查是否有src数据类型异常(步骤S85)。通过执行图55～图69的代码T78来进行该检查。如代码T78所记述的那样，在助记函数的自变量指定的寄存器为向量寄存器的情况下，异常检测部175使用数组“dataTypeVReg”进行检查。例如，异常检测部175判断与在助记函数的自变量指定的两个源寄存器的各个对应的数组“dataTypeVReg”的元素是否相同，在不相同的情况下检测到src数据类型异常。

在图56的代码T78中，在与第一个源寄存器对应的“dataTypeVReg[src0.regIndex]”和与第二个源寄存器对应的“dataTypeVReg[src1.regIndex]”不相等的情况下，异常检测部175检测到src数据类型异常。

此外，在源寄存器为通用寄存器的情况下，异常检测部175也利用“dataTypeGReg”检测src数据类型异常。

通过以上，结束异常检测处理。

根据上述的本实施方式，开发者在定义助记函数的源文件150记述根据图52的(a)、(b)的检测规则检测异常的代码T74～T78。因此，在应用程序用的源文件152有记述错误的情况下，异常检测部175检测起因于该记述错误的异常，并且错误输出部176输出错误。基于该错误，开发者能够容易地调试源文件152，能够实现程序开发的效率化。

并且，通过像这样由异常检测部175检测起因于记述错误的异常，在处理器90无用地执行有记述错误的可执行程序154的时间减少。其结果是，能够改善处理器90、存储器28等硬件资源的不必要的消耗。

并且，上述的代码T74～T78是基于助记函数的自变量表示的寄存器的状态信息145(参照图51)检测异常的代码。通过使用该状态信息145中的各数组，异常检测部175能够检测“R异常”、“W异常”、“数据类型异常”、“数据大小异常”、以及“src数据类型异常”。而且，开发者能够根据检测到这些异常的哪个异常，确定应用程序用的源文件152中的具体的记述错误。

附图标记说明：20…处理器，21…命令解码电路，22…数据获取电路，23…命令执行电路，24…回写电路，25…异常处理电路，26…状态寄存器文件，27…运算用寄存器文件，28…存储器，28a…命令存储器，28b…数据存储器，30…执行电路，31…状态更新电路，32a…第一异常检测部，32b…第二异常检测部，40…选择电路，41…异常检测电路，42…异常信号生成电路，43…数据类型异常检测电路，44…数据大小异常检测电路，45…W异常检测电路，46…src数据类型异常检测电路，47…R异常检测电路，50…异常向量表，60、100…信息处理装置，60a、100a…存储装置，60b、100b…存储器，60c、100c…处理器，60d、100d…通信接口，60e、100e…显示装置，60f、100f…输入装置，60g、100g…总线，60h、100h…记录介质，61…模拟程序，63…控制部，64…存储部，65…环境构建部，66…模拟执行部，70…伪处理器，71…命令解码部，72…数据获取部，73…命令执行部，74…回写部，75…异常处理部，76…状态寄存器文件部，76a…第二存储区域，77…运算用寄存器文件部，77a…第一存储区域，78…存储器部，78a…命令存储器部，78b…数据存储器部，78c…第三存储区域，82…异常检测部，82a…第一异常检测部，82b…第二异常检测部，83…执行部，101…控制部，102…存储部，103…初始化部，104…获取部，105…异常检测部，106…错误输出部，107…状态更新部，108…机器语言生成部，110、145…状态信息，112…汇编程序，117…信息处理装置，153…程序组，171…控制部，172…存储部，175…异常检测部，176…错误输出部，177…状态更新部，178…机器语言生成部，179…写入部。

Claims (20)

1.一种处理器，其特征在于，具有：

第一寄存器；

第二寄存器，储存与上述第一寄存器相关的状态信息；以及

检测电路，基于储存于上述第二寄存器的上述状态信息，检测上述第一寄存器被指定为操作数的命令中的异常。

2.根据权利要求1所述的处理器，其特征在于，

上述状态信息具有第一标志，上述第一标志表示在上述命令的执行前上述第一寄存器是否已被用作写入目的地的寄存器，

在上述第一标志表示上述第一寄存器未被用作写入目的地的寄存器的情况下，上述检测电路检测到上述异常。

3.根据权利要求1所述的处理器，其特征在于，

上述状态信息具有第一标志和第二标志，上述第一标志表示在上述命令的执行前上述第一寄存器是否已被用作写入目的地的寄存器，上述第二标志表示在上述命令的执行前上述第一寄存器是否已被用作读出源的寄存器，

在上述第一标志表示上述第一寄存器已被用作写入目的地的寄存器，并且上述第二标志表示上述第一寄存器未被用作读出源的寄存器的情况下，上述检测电路检测到上述异常。

4.根据权利要求1所述的处理器，其特征在于，

上述状态信息具有类型信息，上述类型信息表示储存于上述第一寄存器的数据的数据类型，

在上述类型信息表示的上述数据类型与上述命令设为运算的对象的数据类型不一致的情况下，上述检测电路检测到上述异常。

5.根据权利要求1所述的处理器，其特征在于，

上述第一寄存器是储存向量数据的多个元素的向量寄存器，

上述状态信息具有大小信息，上述大小信息表示储存于上述第一寄存器的上述元素的数据大小，

在上述大小信息表示的数据大小与在上述操作数中指定的上述第一寄存器的数据大小不一致的情况下，上述检测电路检测到上述异常。

6.根据权利要求1所述的处理器，其特征在于，

上述处理器具有多个上述第一寄存器，并且分别与多个上述第一寄存器对应地具有多个上述第二寄存器，

上述状态信息具有类型信息，上述类型信息表示储存于上述第一寄存器的数据的数据类型，

在上述命令中多个上述第一寄存器被指定为多个源寄存器的各个源寄存器的情况下，并且在上述命令以储存于多个上述源寄存器的各个源寄存器的数据的数据类型彼此相同为前提时，在各上述第一寄存器的上述类型信息彼此不一致的情况下，上述检测电路检测到上述异常。

7.根据权利要求1所述的处理器，其特征在于，

上述处理器还具有执行电路，上述执行电路执行将储存于上述第二寄存器的上述状态信息保存于上述第一寄存器的第一存储命令、和将保存于上述第一寄存器的上述状态信息写入到上述第二寄存器的第一载入命令。

8.根据权利要求1所述的处理器，其特征在于，

上述处理器还具有执行电路，上述执行电路执行将储存于上述第二寄存器的上述状态信息保存于存储器的第二存储命令、和将保存于上述存储器的上述状态信息写入到上述第二寄存器的第二载入命令。

9.根据权利要求1所述的处理器，其特征在于，

上述处理器具有多个上述第一寄存器，并且分别与多个上述第一寄存器对应地具有多个上述第二寄存器，

上述处理器还具有执行电路，上述执行电路执行将储存于多个上述第二寄存器的各个第二寄存器的多个上述状态信息一并保存于存储器的第三存储命令、和将保存于上述存储器的多个上述状态信息一并写入到各上述第二寄存器的第三载入命令。

10.根据权利要求1所述的处理器，其特征在于，

上述处理器还具有执行电路，上述执行电路执行使检测上述异常的上述检测电路的功能无效的无效命令、和使上述功能有效的有效命令。

11.根据权利要求10所述的处理器，其特征在于，

上述无效命令和上述有效命令分别取异常的种类作为操作数，

上述执行电路通过执行上述无效命令来使检测上述种类的上述异常的上述功能无效，通过执行上述有效命令来使检测上述种类的上述异常的上述功能有效。

12.根据权利要求10所述的处理器，其特征在于，

上述处理器具有多个上述第二寄存器，

并且上述无效命令和上述有效命令分别取多个上述第二寄存器中的一个第二寄存器作为操作数，

上述执行电路使用储存于被指定为上述无效命令的上述操作数的上述第二寄存器的上述状态信息来使检测上述异常的上述功能无效，使用储存于被指定为上述有效命令的上述操作数的上述第二寄存器的上述状态信息来使检测上述异常的上述功能有效。

13.一种模拟程序，用于使计算机执行：

在存储器确保模拟第一寄存器的第一存储区域的处理；

在上述存储器确保模拟第二寄存器的第二存储区域的处理，上述第二寄存器储存与上述第一寄存器相关的状态信息；以及

基于储存于上述第二寄存器的上述状态信息，检测上述第一寄存器被指定为操作数的命令中的异常的处理。

14.根据权利要求13所述的模拟程序，其特征在于，

上述状态信息具有第一标志，上述第一标志表示在上述命令的执行前上述第一寄存器是否已被用作写入目的地的寄存器，

在检测上述异常的处理中，在上述第一标志表示上述第一寄存器未被用作写入目的地的寄存器的情况下，检测到上述异常。

15.根据权利要求13所述的模拟程序，其特征在于，

上述状态信息具有第一标志和第二标志，上述第一标志表示在上述命令的执行前上述第一寄存器是否已被用作写入目的地的寄存器，上述第二标志表示在上述命令的执行前上述第一寄存器是否已被用作读出源的寄存器，

在检测上述异常的处理中，在上述第一标志表示上述第一寄存器已被用作写入目的地的寄存器，并且上述第二标志表示上述第一寄存器未被用作读出源的寄存器的情况下，检测到上述异常。

16.根据权利要求13所述的模拟程序，其特征在于，

上述状态信息具有类型信息，上述类型信息表示储存于上述第一寄存器的数据的数据类型，

在检测上述异常的处理中，在上述类型信息表示的数据类型与上述命令设为运算的对象的数据类型不一致的情况下，检测到上述异常。

17.根据权利要求13所述的模拟程序，其特征在于，

上述第一寄存器是储存向量数据的多个元素的向量寄存器，

上述状态信息具有大小信息，上述大小信息表示储存于上述第一寄存器的上述元素的数据大小，

在检测上述异常的处理中，在上述大小信息表示的数据大小与在上述操作数中指定的上述第一寄存器的数据大小不一致的情况下，检测到上述异常。

18.根据权利要求13所述的模拟程序，其特征在于，

上述第一存储区域模拟多个上述第一寄存器，并且上述第二存储区域模拟分别与多个上述第一寄存器对应的多个上述第二寄存器，

上述状态信息具有类型信息，上述类型信息表示储存于上述第一寄存器的数据的数据类型，

在上述命令中多个上述第一寄存器被指定为多个源寄存器的各个源寄存器的情况下，并且在上述命令以储存于多个上述源寄存器的各个源寄存器的数据的数据类型彼此相同为前提时，在检测上述异常的处理中，在各上述第一寄存器的上述类型信息彼此不一致的情况下，检测到异常。

19.一种汇编程序，用于使计算机执行：

获取寄存器被指定为操作数的命令的汇编语言的代码的处理；

基于与上述寄存器相关的状态信息，检测上述命令中的异常的处理；

在检测到上述异常时输出错误的处理；以及

在未检测到上述异常时生成上述代码的机器语言的处理。

20.一种信息处理程序，其特征在于，具有：

在接受到将表示被指定为命令的操作数的寄存器的自变量与上述命令建立了对应关系的函数时，基于与上述自变量表示的上述寄存器相关的状态信息，检测上述命令中的异常的处理；

在检测到上述异常时输出错误的处理；

在未检测到上述异常时生成机器语言的处理，上述机器语言表示上述命令对上述操作数进行的处理；以及

将上述机器语言写入到存储器的处理。

Images