JP3280332B2 - ループに対するバージョニングを実行する方法及び装置、配列レンジ・チェックに関する情報をベーシック・ブロック内において収集する方法及び装置、配列レンジ・チェックに関する情報を変更する方法、配列レンジ・チェック最適化方法、配列レンジ・チェックのためのコードを生成する方法、不要配列レンジ・チェック除去方法及び装置、配列レンジ・チェックを選択する方法、配列レンジ・チェック変更方法、配列レンジ・チェック収集方法、及び配列レンジ・チェック取扱判断方法 - Google Patents

Description

【発明の詳細な説明】

【０００１】

【発明の属する技術分野】本発明は、コンパイラに関
し、より詳しくは、コンパイラにおいて配列レンジ・チ
ェックを除去又は最適化する方法に関する。配列レンジ
・チェックとは、プログラムにおける配列アクセスがそ
の配列の範囲を越えているか否かに関する検査である。

【０００２】

【従来の技術】従来技術における配列レンジ・チェック
の除去方法には、次のようなものがある。 （１）ループ前でレンジが超える可能性をチェックする
方法（Priyadarshan Kolte and Michael Wolfe: Elimin
ation of Redundant Array Subscript Range Checks. I
n proceedings of the ACM SIGPLAN '95 Conference on
Programming Language Design and Implementation, P
ages270-278, Jun 1995.等を参照のこと) 配列の下限を０、配列の大きさをＮとする表１を表２の
ように変形する。

【表１】for (i = start; i <= end; i++) a[i] = 0;

【表２】 if ((start <= end) && (start < 0 || end > N-1)){ exception; /* ループ内で配列のレンジを越える */ } for (i = start; i <= end; i++) a[i] = 0; /* チェック不要 */

【０００３】表１の擬似コードでは、配列ａの各要素に
０を代入している。表２の擬似コードでは、ｉｆ文の条
件を満たす場合には配列のレンジを越えるような配列ア
クセスであるため例外（exception）を発生させ、満た
さない場合には表１と同じ処理を実施するようになって
いる。

【０００４】この方法の長所は、ループ内の配列アクセ
スの上限、下限が確実に分かる場合、ループ内の全ての
配列レンジ・チェックを除去できる点である。しかし、
以下のような欠点も有する。すなわち、この方法はレン
ジを超えるのは誤りであるという仕様の言語にしか適用
できない。また、ループ内の配列インデックスが単調変
化する時にしか適用できない。さらに、ループの終了条
件をループの外に出せない場合、例えば上の例において
endがグローバル変数等で、ループ内で自分自身あるい
は他のスレッドがendを変えるような時には適用できな
い。

【０００５】（２）ループを３つに分ける方法（Samuel
P. Midkiff, Jose E. Moreira, MarcSnir: Optimizing
Array Reference Checking in Java Programs. IBM Re
search Report RC21184(94652) 05/18/98 Computer Sci
ence/Mathematics 等を参照のこと） ループを下限値のチェック部分、チェック不要部分、上
限値のチェック部分の３つに分ける方法である。例え
ば、配列の下限を０、 配列の大きさをＮとすると、表
１は表３のように変形される。

【表３】 for (i = start; i <= min( max(start, 0)-1, end ); i++) a[i] = 0; for (i = max( start, 0 ); i <= min( end, N-1 ); i++) a[i] = 0; /* チェック不要 */ for (i = max( start, min( end, N-1 ) + 1 ); i <= end; i++) a[i] = 0;

【０００６】このように３つに分けると２つ目のforル
ープはレンジ・チェックを省くことができる。この方法
における基本的な考え方は（１）と類似している。この
方法の長所は、ループ内の配列アクセスの上限、下限が
確実に分かる場合、ループ内の全ての配列レンジ・チェ
ックを除去できる点である。しかし、この方法はループ
内の配列インデックスが単調変化する時にしか適用でき
ない。また、ループの終了条件をループの外に出せない
場合、例えば上の例においてendがグローバル変数等
で、ループ内で自分自身あるいは他のスレッドがendを
変えるような時には適用できない。さらに、コードサイ
ズが３倍になるので大きいループに適用する際は特別な
取扱いが必要となる。

【０００７】（３）同じ値の配列ベース、インデックス
はチェック済みにする方法（参考文献は（１）と同じ） この方法は、チェック済みのa[i]という配列アクセスが
あった場合、そこから支配されていて a 及び i の値が
変わらない範囲でのa[i]をチェック済みにするものであ
る。例を表４に示す。

【表４】

【０００８】この方法の長所は、ループ以外の場所につ
いても適用できる点にある。しかし、チェック済と判断
できる範囲が狭いという欠点がある。

【０００９】（４）変数の持つ値のレンジを使って配列
チェック除去を行う方法（CRAIG CHAMBERS, DAVID UNGA
R: Iterative Type Analysis and Extended Message Sp
litting: Optimizing Dynamically-Typed Object-Orien
ted Programs 等を参照のこと) if 文などの情報から変数の持つ値の範囲を狭め、その
情報を利用して配列レンジ・チェック除去をする方法で
ある。例えば、配列の下限を０とした時、コメント部分
にチェック不要と書かれた部分が本方法によりチェック
不要と判断される配列アクセスである。

【表５】 if (3 <= i && i <= 5){ /* iの持つ値の範囲は 3 〜 5 だと分かる。 */ a[i] = j; /* チェック必要 */ a[i-1] = 0; /* チェック不要 0 < i-1 < iより */ a[(i-3)*2] = 0; /* チェック不要 0 <= (i-3)*2 < i より */ }

【００１０】この方法の長所はループ以外の場所につい
ても適用できる点にある。（１）のように配列インデッ
クスの式が複雑であってもチェック済みと扱える可能性
がある。しかし、実際には変数の値の範囲を狭められな
いケースが多い。

【００１１】（５）データ・フロー解析（Data-flow an
alysis）を用いて配列チェック除去を行う方法（R. Gup
ta. Optimizing array bound checks using flow analy
sis. ACM Letters on Programming Languages and Syst
ems, 2(1-4): 135-150, March-December 1993.等を参照
のこと） この方法は、次のような２段階の処理で配列レンジ・チ
ェックを除去する。すなわち、（１）配列レンジ・チェ
ックを減らすために実行順の最初の方にチェックを挿入
する。（２）不要な配列レンジ・チェックを除去する。

【００１２】この方法の長所はループ以外の場所につい
ても適用できる点にある。しかし、配列レンジ・チェッ
クを除去できる範囲が狭く、レンジを超えるのは誤りで
あるという仕様の言語にしか適用できないという欠点が
ある。

【００１３】

【発明が解決しようとする課題】本発明の目的は、デー
タ・フロー解析等を使用して配列レンジ・チェック情報
を収集し、チェックの前倒し等を行うことにより、不要
な配列レンジ・チェックを除去することである。なお、
ここで言う不要な配列レンジ・チェックとは、先行する
配列アクセスにより、その配列アクセスではそのレンジ
を越えないことが保証できる配列アクセスに対する配列
レンジ・チェックのことである。

【００１４】また、Ｊａｖａ（Sun Microsystems社の商
標）言語は仕様として配列アクセス時のレンジ・チェッ
クの結果により例外（Exception）が起きる。そして、
この例外の発生を利用してプログラムを書くことができ
るため、配列レンジ・チェックを行わないとプログラム
が正しく動作しなくなってしまう。本発明は、例外の発
生を利用してプログラムを書くことができる言語にも対
応させ、より多くの配列レンジ・チェックを除去できる
ようにすることも目的である。

【００１５】さらに、データ・フロー解析等を行って配
列レンジ・チェック情報を収集し、配列レンジ・チェッ
クの最適化を行うことも目的である。

【００１６】また、所定の条件にて配列レンジ・チェッ
ク情報を収集し、ループのバージョニングを行うことも
目的である。

【００１７】

【課題を解決するための手段】以上の目的を達成するた
めに、本発明は以下の３つ大きな部分に分類できる。す
なわち、Ａ．ループに対するバージョニングにより不要
な配列レンジ・チェックを除去する部分と、Ｂ．データ
・フロー解析を実行順序とは逆順に行って配列レンジ・
チェックを最適化する部分、及びＣ．データ・フロー解
析を実行順に行って配列レンジ・チェック済の情報を取
得し、この情報から不要な配列レンジ・チェックを除去
する部分である。

【００１８】Ａ．では以下のような処理を実施する（実
施例では図２）。すなわち、プログラム内の配列アクセ
スに対する配列レンジ・チェックの情報を用いて、ルー
プに対しバージョニングを実行する場合には、各ベーシ
ック・ブロック内において、実行とは逆順に、第１の条
件（実施例では表８）に従って配列レンジ・チェックの
集合である第１要処理配列レンジ・チェック情報（実施
例ではＣ＿ＧＥＮ［Ｂ］）を収集し且つ記憶装置に記憶
する収集ステップと、深さ優先探索（ＤＦＳ：Depth−F
irst Search）のポストオーダー・トラバーサル（Posto
rder Traversal）の順番で、第１要処理配列レンジ・チ
ェック情報を第２の条件に従って伝搬させ（実施例で
は、Backward(C_OUT[B], B)（表９）及びそれを用いた
処理（図３））、各ベーシック・ブロックの先頭におけ
る第２要処理配列レンジ・チェック情報（実施例ではＣ
＿ＩＮ［Ｂ］）を生成し且つ記憶装置に記憶する第２要
処理配列レンジ・チェック情報生成ステップと、第２要
処理配列レンジ・チェック情報を用いて、ループの前に
バージョニングのためのチェック・コード、及び各実行
状態における実行コードを生成し、記憶装置に記憶する
ステップとを実施する。これにより、チェック・コード
による分類で配列レンジ・チェックなしのループ、及び
配列レンジ・チェックありのループの２つの実行状態に
分けられるので、配列レンジ・チェックなしのループに
実行が遷移すれば、処理が高速化される。

【００１９】上で述べた第１の条件には、ベーシック・
ブロック内において、（１）配列アクセスのインデック
ス変数が変更されない場合には当該配列アクセスに対す
る配列レンジ・チェックの情報をそのまま収集し、
（２）配列レンジ・チェックにおけるインデックス変数
が正又は負の定数の加算により変更されている場合には
当該インデックス変数にその定数を加算することにより
生ずる変更を反映させた後の配列レンジ・チェックの情
報を収集するという条件を含むようにすることが考えら
れる。後者の条件により、取扱い可能な配列レンジ・チ
ェックの範囲が拡張されている。

【００２０】上で述べた第２の条件には、あるベーシッ
ク・ブロックの第１要処理配列レンジ・チェック情報
と、当該あるベーシック・ブロックの後端における第３
要処理配列レンジ・チェック情報（実施例ではＣ＿ＯＵ
Ｔ［Ｂ］）を第３の条件（実施例ではbackward(C_OUT
[B], B)）に従って変更した第４要処理配列レンジ・チ
ェック情報との和集合を計算するという条件を含むよう
にすることも考えられる。

【００２１】上で述べた第３の条件には、あるベーシッ
ク・ブロックにおいて、第３要処理配列レンジ・チェッ
ク情報に含まれる配列レンジ・チェックにおけるインデ
ックス変数が正又は負の定数の加算により変更される場
合、当該インデックス変数に定数を加算することにより
生ずる変更を第３要処理配列レンジ・チェック情報に含
まれる配列レンジ・チェックに反映させる、という条件
を含むようにするとも考えられる。

【００２２】上で述べた第３要処理配列レンジ・チェッ
ク情報が、あるベーシック・ブロックの直後のベーシッ
ク・ブロックであって当該あるベーシック・ブロックと
同じループに含まれる全てのベーシック・ブロックの第
２要処理配列レンジ・チェック情報を用いて生成される
ように構成することも可能である。

【００２３】上で述べた収集ステップは、さらに詳しく
説明すると、ベーシック・ブロック内の命令を、実行と
は逆順で、検査するステップと、当該検査においてこの
命令が配列アクセスを含む場合、当該配列アクセスに対
して必要となる配列レンジ・チェックの情報を記憶装置
に記憶するステップと、検査においてその命令が、記憶
された配列レンジ・チェックに関連する配列インデック
ス変数の変更を含む場合には、当該変更が配列インデッ
クス変数の正又は負の定数の加算であるか判断するステ
ップと、変更がその定数の加算である場合には、配列レ
ンジ・チェックにおける配列インデックス変数に定数を
加算することにより生じる、配列レンジ・チェックの変
更を計算するステップと、計算された配列レンジ・チェ
ックの変更を反映した後の配列レンジ・チェックを記憶
装置に記憶するステップとを含む。これは、従来技術
（５）の手法では取り扱われなかった処理である。

【００２４】なお、以下で説明するＢ．の場合には、収
集ステップは、以下のようなステップを含み得る。すな
わち、検査においてその命令が、配列レンジ・チェック
により発生する例外が当該命令より先に起こることによ
って副作用を生じるような命令である場合には、当該検
査までに記憶された配列レンジ・チェックを破棄するス
テップである。Ｂ．の場合には、副作用を生じるような
命令がある場合には処理不可能だからである。

【００２５】次にＢ．の場合（実施例では図４）を説明
する。すなわち、プログラム内の配列アクセスに対する
配列レンジ・チェックを最適化する場合には、各ベーシ
ック・ブロック内において、実行とは逆順に、第１の条
件（実施例では表１２）に従って配列レンジ・チェック
の集合である第１要処理配列レンジ・チェック情報（実
施例ではＣ＿ＧＥＮ［Ｂ］）を収集し且つ記憶装置に記
憶する収集ステップと、プログラムにおけるデータ・フ
ロー解析（Data Flow Analysis）により、ベーシック・
ブロック中に例外を発生させる配列レンジ・チェックを
それより前に移動させることによって副作用を生じるよ
うな副作用命令を含むか否かの情報を用い且つ第２の条
件（実施例では、backward(C_OUT[B]、表１３、及び図
５）に従って第１要処理配列レンジ・チェック情報を伝
搬させ、各ベーシック・ブロックの後端における第２要
処理配列レンジ・チェック情報（実施例ではＣ＿ＯＵＴ
［Ｂ］）を生成し且つ記憶装置に記憶する第２要処理配
列レンジ・チェック情報生成ステップと、各ベーシック
・ブロック内において、第２要処理配列レンジ・チェッ
ク情報を第３の条件（実施例では表１４）に従い修正し
ながら実行とは逆順に各命令をたどり、第２要処理配列
レンジ・チェック情報を用いて配列レンジ・チェックの
ためのコードを生成し且つ記憶装置に記憶するコード生
成ステップと、を実行する。この処理自体では配列レン
ジ・チェックは除去されないが、Ａ．又はＣ．又はＡ．
且つＣ．と合わせて用いることにより、より好ましい配
列レンジ・チェックへ変換することができる。従来技術
の手法と組み合わせることも可能である。

【００２６】上で述べた第１の条件には、ベーシック・
ブロック内において、（１）配列アクセスのインデック
ス変数が変更されない場合には当該配列アクセスに対す
る配列レンジ・チェックの情報をそのまま収集し、
（２）配列レンジ・チェックにおけるインデックス変数
が正又は負の定数の加算により変更されている場合には
当該インデックス変数にその定数を加算することにより
生ずる変更を反映させた後の配列レンジ・チェックの情
報を収集し、（３）ベーシック・ブロックが副作用命令
を含む場合には、当該ベーシック・ブロックにおいて収
集した配列レンジ・チェックの情報を破棄する、という
条件を含むようにすることも考えられる。（２）及び
（３）の条件は、従来では取り扱われなかったものであ
る。

【００２７】上で述べた第２の条件には、（１）あるベ
ーシック・ブロックがプログラムの終端である場合又は
あるベーシック・ブロックがプログラムの終端でなく且
つ副作用命令を含む場合には、当該あるベーシック・ブ
ロックの第１要処理配列レンジ・チェック情報そのもの
を、（２）あるベーシック・ブロックがプログラムの終
端でなく且つ副作用命令を含まない場合には、あるベー
シック・ブロックの第２要処理配列レンジ・チェック情
報を第４の条件に従って変更した第３要処理配列レンジ
・チェック情報とあるベーシック・ブロックの第１要処
理配列レンジ・チェック情報の和集合を、あるベーシッ
ク・ブロックの先頭における要処理配列レンジ・チェッ
ク情報として伝搬するという条件を含むようにすること
も考えられる。

【００２８】上で述べた第３の条件には、（１）配列レ
ンジ・チェックにおけるインデックス変数が正又は負の
定数の加算により変更されている場合には当該インデッ
クス変数にその定数を加算することにより生ずる変更を
反映させた後の配列レンジ・チェックの情報に修正し、
（２）ベーシック・ブロックが副作用命令を含む場合に
は、当該ベーシック・ブロックにおいて収集した配列レ
ンジ・チェックの情報を破棄するという条件を含むよう
にすることも考えられる。

【００２９】また、上で述べたコード生成ステップが、
配列アクセスに対する配列レンジ・チェックの範囲が、
第２要処理配列レンジ・チェック情報に含まれる配列レ
ンジ・チェックの範囲より狭い場合には、当該配列アク
セスに対して、第２要処理配列レンジ・チェック情報に
含まれる配列レンジ・チェックのためのコードを生成す
るステップを含むようにすることも考えられる。

【００３０】上で述べた第４の条件には、あるベーシッ
ク・ブロックにおいて、第２要処理配列レンジ・チェッ
ク情報に含まれる配列レンジ・チェックにおけるインデ
ックス変数が正又は負の定数の加算により変更される場
合、当該インデックス変数にその定数を加算することに
より生ずる変更を第２要処理配列レンジ・チェック情報
に含まれる配列レンジ・チェックに反映させる、という
条件を含むようにすることも考えられる。

【００３１】上で述べたコード生成ステップをさらに詳
しく述べると、プログラム内の配列レンジ・チェックを
最適化する場合に、各ベーシック・ブロックの後端まで
に伝搬された、配列アクセスに対して必要となる配列レ
ンジ・チェックの集合である要処理配列レンジ・チェッ
ク情報（実施例ではＣ＿ＯＵＴ［Ｂ］）を用いて、挿入
すべき、配列レンジ・チェックのためのコードを生成す
る場合には、ベーシック・ブロック内の命令を、実行と
は逆順に、検査するステップと、当該検査においてその
命令が配列アクセスを含む場合、要処理配列レンジ・チ
ェック情報内の配列レンジ・チェックの範囲より、当該
配列アクセスに必要な配列レンジ・チェックの範囲が狭
いか判断するステップと、狭いと判断された場合には、
要処理配列レンジ・チェック情報内の配列レンジ・チェ
ックに対応するコードを生成するステップと、検査にお
いてその命令が、要処理配列レンジ・チェック情報に含
まれる配列のインデックス変数の変更を含む場合には、
当該変更が配列インデックス変数の正又は負の定数の加
算であるか判断するステップと、変更が定数の加算であ
る場合には、その定数を記憶装置に記憶するステップ
と、変更が定数の加算である場合には、配列レンジ・チ
ェックにおけるインデックス変数にその定数を加算する
ことにより生じる、配列レンジ・チェックの変更を計算
するステップと、計算された配列レンジ・チェックの変
更を反映した後の配列レンジ・チェックを記憶装置に記
憶するステップとを実行する。要処理配列レンジ・チェ
ック情報には、配列レンジ・チェックに対応するコード
を生成すべき範囲が含まれており、これを変形して用い
ながら最適な配列レンジ・チェックのためのコードを生
成する。

【００３２】上の検査において命令が、例外を発生させ
る配列レンジ・チェックをそれより前に移動させること
によって副作用を生じるような命令であるか判断するス
テップと、判断が真である場合、要処理配列レンジ・チ
ェック情報を破棄するステップとを含むようにすること
も考えられる。本発明では取り扱えない場合を示してい
る。

【００３３】Ｃ．では以下のような処理を実施する（実
施例では図７）。すなわち、プログラム内の配列レンジ
・チェックのうち不要な配列レンジ・チェックを除去す
る場合には、各ベーシック・ブロック内において、実行
の順番で、第１の条件（実施例では表１６）に従って配
列レンジ・チェックの集合である第１処理済配列レンジ
・チェック情報（実施例ではＣ＿ＧＥＮ［Ｂ］）を収集
する収集ステップと、プログラムにおけるデータ・フロ
ーに従って、第１処理済配列レンジ・チェック情報を第
２の条件（実施例では、表１７及び図８）に従って伝搬
させ、各ベーシック・ブロックの先頭における第２処理
済配列レンジ・チェック情報（実施例ではＣ＿ＩＮ
［Ｂ］）を生成する第２処理済配列レンジ・チェック情
報生成ステップと、各ベーシック・ブロック内におい
て、第２処理済配列レンジ・チェック情報を第３の条件
（実施例では表１８）に従って修正しつつ実行の順番に
各命令をたどり、第２処理済配列レンジ・チェック情報
を用いて配列レンジ・チェックを除去するステップとを
実行する。データ・フロー解析を用いて不要な配列レン
ジ・チェックを除去していく。

【００３４】上で述べた第１の条件には、ベーシック・
ブロック内において、（１）配列アクセスのインデック
ス変数が変更されない場合には当該配列アクセスに対す
る配列レンジ・チェックの情報をそのまま収集し、
（２）配列レンジ・チェックにおけるインデックス変数
が正又は負の定数の加算により変更されている場合には
当該インデックス変数にその定数を減算することにより
生ずる変更を反映させた後の配列レンジ・チェックの情
報を収集する、という条件を含むようにすることも考え
られる。（２）の場合を含むため、従来より除去できる
配列レンジ・チェックの範囲が広い。

【００３５】さらに、上で述べた第１の条件には、配列
レンジ・チェックにおける配列インデックスの最小定数
オフセット及び最大定数オフセット及び配列の下限か
ら、定数インデックスについてチェック済みとして扱う
ことができる上限及び下限で規定される範囲を収集す
る、という条件を含むようにすることも可能である。さ
らに除去範囲が広がる。

【００３６】さらに、上で述べた第１の条件には、配列
レンジ・チェックにおけるインデックス変数の下限値又
は上限値及び配列の下限から、定数インデックスについ
てチェック済みとして扱うことができる上限及び下限で
規定される範囲を収集する、という条件を含むようにす
ることも考えられる。

【００３７】また、上で述べた第２の条件には、（１）
あるベーシック・ブロックがプログラムの先頭である場
合にはあるベーシック・ブロックの第１処理済配列レン
ジ・チェック情報そのものを、（２）あるベーシック・
ブロックがプログラムの先頭でない場合にはあるベーシ
ック・ブロックの第２処理済配列レンジ・チェック情報
を第４の条件に従って変更した第３処理済配列レンジ・
チェック情報とあるベーシック・ブロックの第１処理済
配列レンジ・チェック情報の和集合を、あるベーシック
・ブロックの後端における要処理配列レンジ・チェック
情報として伝搬する、という条件を含むようにすること
も考えられる。

【００３８】上で述べた第３の条件には、配列レンジ・
チェックにおけるインデックス変数が正又は負の定数の
加算により変更されている場合には当該インデックス変
数にその定数を減算することにより生ずる変更を反映さ
せた後の配列レンジ・チェックの情報に修正する、とい
う条件を含むようにすることも考えられる。

【００３９】上で述べた第４の条件には、あるベーシッ
ク・ブロックにおいて、第２処理済配列レンジ・チェッ
ク情報に含まれる配列レンジ・チェックにおけるインデ
ックス変数が正又は負の定数の加算により変更される場
合、当該インデックス変数にその定数を減算することに
より生ずる変更を第２処理済配列レンジ・チェック情報
に含まれる配列レンジ・チェックに反映させる、という
条件を含むようにすることも考えられる。

【００４０】上で述べた配列レンジ・チェックを除去す
るステップ（実施例では表１８）をさらに詳しく説明す
ると以下のとおりになる。すなわち、プログラム内の配
列レンジ・チェックのうち不要なものを除去する場合
に、各ベーシック・ブロックの先頭に伝搬された、配列
アクセスに対する配列レンジ・チェックの集合である処
理済配列レンジ・チェック情報（実施例ではＣ＿ＩＮ
［Ｂ］）を用いて、除去の対象となる配列レンジ・チェ
ックを選択する場合には、ベーシック・ブロック内の命
令を、実行の順番で、検査するステップと、当該検査に
おいてその命令が配列アクセスを含む場合、当該配列ア
クセスに必要な配列レンジ・チェックの範囲が処理済配
列レンジ・チェック情報に含まれる配列レンジ・チェッ
クの範囲でカバーされるのか判断するステップと、カバ
ーされると判断された場合には、配列アクセスに必要な
配列レンジ・チェックを選択するステップと、上の検査
において命令が、処理済配列レンジ・チェック情報に含
まれる配列レンジ・チェックのインデックス変数の変更
を含む場合には、当該変更がインデックス変数の正又は
負の定数の加算であるか判断するステップと、変更が定
数の加算である場合には、定数を記憶装置に記憶するス
テップと、その変更が定数の加算である場合には、配列
レンジ・チェックにおけるインデックス変数に定数を減
算することにより生じる、配列レンジ・チェックの変更
を計算するステップと、計算された配列レンジ・チェッ
クの変更を反映した後の配列レンジ・チェックを記憶装
置に記憶するステップとを実行する。これにより除去さ
れる配列レンジ・チェックの範囲が広がる。

【００４１】上で述べた、カバーされるのか判断するス
テップが、処理済配列レンジ・チェック情報に、同一の
配列ベースを有する配列レンジ・チェックについて、イ
ンデックス変数Ｉ_k（ｋ＝１，．．．ｎ）が含まれてい
るか検査するステップと、全てのｋについてインデック
ス変数Ｉ_kが含まれていると判断された場合、定数Ｌと
ｎの関係が所定の条件に合致しているか判断するステッ
プと、定数Ｌとｎの関係が所定の条件に合致している場
合、（Ｉ₁＋Ｉ₂＋．．．＋Ｉ_n）／Ｌが配列インデック
スである配列アクセスの配列レンジ・チェックを選択す
るステップと、を含むようにすることも考えられる。こ
れにより、さらに除去可能な配列レンジ・チェックの範
囲が広がる。

【００４２】また、カバーされるのか判断するステップ
が、処理済配列レンジ・チェック情報に、定数インデッ
クスに関する配列レンジ・チェックについて、定数Ｎの
絶対値に１を減じた定数が含まれているか検査するステ
ップと、定数Ｎの絶対値に１を減じた定数が含まれてお
り且つ処理済配列レンジ・チェック情報に定数０が実質
的に含まれている場合には、配列インデックスであるＡ
mod ＮのＡが正であるか判断するステップと、Ａが正
である場合、配列インデックスＡ mod Ｎを含む配列ア
クセスの配列レンジ・チェックを選択するステップとを
含むようにすることも考えられる。これにより、さらに
除去可能な配列レンジ・チェックの範囲が広がる。

【００４３】なお、Ａ．及びＢ．の収集ステップ及び第
２要処理配列レンジ・チェック情報生成ステップにおけ
る処理の一部は、プログラム内の配列アクセスが配列の
レンジを越えていないことを検査するための配列レンジ
・チェックをプログラム実行とは逆方向に移動させる処
理と考えることができ、この場合に配列レンジ・チェッ
クを変更するには、配列レンジ・チェックが当該配列の
インデックス変数に正又は負の定数を加算する処理を越
えて移動することになるか判断し、その定数を記憶装置
に記憶するステップと、判断が真である場合には、配列
レンジ・チェックにおけるインデックス変数にその定数
を加算することにより生じる、配列レンジ・チェックの
変更を計算するステップと、計算された配列レンジ・チ
ェックの変更を反映した後の配列レンジ・チェックを記
憶装置に記憶するステップとを実行する。

【００４４】また、Ｃ．の収集ステップ及び第２要処理
配列レンジ・チェック情報生成ステップにおける処理の
一部は、プログラム内の配列アクセスが配列のレンジを
越えていないことを検査するための配列レンジ・チェッ
クをプログラム実行と同一方向に移動させる処理と考え
ることができ、この場合に配列レンジ・チェックを変更
するには、配列レンジ・チェックが当該配列のインデッ
クス変数に正又は負の定数を加算する処理を越えて移動
することになるか判断し、前記定数を記憶装置に記憶す
るステップと、判断が真である場合には、配列レンジ・
チェックにおけるインデックス変数に前記定数を減算す
ることにより生じる、配列レンジ・チェックの変更を計
算するステップと、計算された配列レンジ・チェックの
変更を反映した後の配列レンジ・チェックを記憶装置に
記憶するステップとを実行する。

【００４５】Ｃ．の収集ステップにおける特徴的な処理
をさらに詳しく述べると、プログラム内の配列アクセス
が配列のレンジを越えていないことを検査するための配
列レンジ・チェックであってチェック済みであるとして
取り扱うことができる配列レンジ・チェックをプログラ
ムのベーシック・ブロック内において収集する処理であ
って、配列レンジ・チェックを検出するステップと、検
出された配列レンジ・チェックを記憶装置に記憶するス
テップと、検出された配列レンジ・チェックにおける配
列インデックスの最小定数オフセット及び最大定数オフ
セット及び配列の下限から、定数インデックスについて
チェック済みとして扱うことができる上限及び下限を計
算し且つ記憶するステップと、計算された上限及び下限
で規定される範囲に関する配列レンジ・チェックを記憶
装置に記憶するステップとを含む。

【００４６】Ｃ．の配列レンジ・チェックを除去するス
テップにおける特徴的な処理をさらに詳しく述べると、
プログラム内の配列アクセスが配列のレンジを越えてい
ないことを検査するための配列レンジ・チェックがチェ
ック済みであるとして取り扱うことができるか判断する
処理であって、チェック済みであると決定された配列レ
ンジ・チェックを記憶装置に記憶するステップと、チェ
ック済みであると決定され且つ同一の配列ベースを有す
る配列レンジ・チェックについて、インデックス変数Ｉ
_k（ｋ＝１，．．．ｎ）が記憶装置に記憶されているか
検査するステップと、定数Ｌとｎの関係が所定の条件に
合致しているか判断するステップと、全てのｋについて
前記インデックス変数Ｉ_kが記憶されていると判断され
且つ定数Ｌとｎの関係が所定の条件に合致している場
合、（Ｉ₁＋Ｉ₂＋．．．＋Ｉ_n）／Ｌが配列インデック
スである配列アクセスをチェック済みであるとして記憶
装置に記憶するステップとを含む。

【００４７】同様な処理において、チェック済みである
と決定された配列レンジ・チェックを記憶装置に記憶す
るステップと、チェック済みであると決定され且つ定数
インデックスに関する配列レンジ・チェックについて、
定数Ｎの絶対値に１を減じた定数が記憶装置に記憶され
ているか検査するステップと、配列インデックスである
Ａ mod ＮのＡが正であるか判断するステップと、定数
Ｎの絶対値に１を減じた定数が記憶装置に記憶されてお
り且つ定数０が実質的にチェック済みであり（配列イン
デックスの下限が０である場合及びそうでない場合を含
む）且つＡが正である場合、前記配列インデックスＡ m
od Ｎをチェック済みであるとして記憶装置に記憶する
ステップとを実行することも可能である。

【００４８】以上本発明を処理のフローとして表現して
きたが、以上の処理を実行するコンピュータ及びコンピ
ュータ・プログラム又は専用の回路又は装置により実施
することも可能である。なお、コンピュータ・プログラ
ムにより実施する場合には、ＣＤ−ＲＯＭやフロッピー
・ディスク、ハードディスクのような記憶媒体にコンピ
ュータ・プログラムを格納する場合がある。

【００４９】

【発明の実施の形態】Ｊａｖａを用いた環境における、
本発明の装置構成を図１を用いて説明する。サーバ・コ
ンピュータ１及びクライアント・コンピュータ５はネッ
トワーク３を介して接続されている。クライアント・コ
ンピュータ５は、ＪａｖａＶＭ（Virtual Machine）５
２及びＯＳ（Operating System）５３及びハードウエア
（ＣＰＵ及びメモリを含む）５５を含む。さらに、Ｊａ
ｖａＶＭ５２は、Ｊａｖａインタープリタ５４又はＪａ
ｖａ ＪＩＴコンパイラ５６を含む。インタープリタ５
４及びＪＩＴコンパイラ５６の両者を有している場合も
ある。なお、クライアント・コンピュータ５は、通常の
コンピュータの他、メモリの大きさが小さかったり、ハ
ードディスク等の補助記憶装置を含まないような、いわ
ゆるネットワーク・コンピュータや情報家電の場合もあ
る。

【００５０】サーバ・コンピュータ１では、Ｊａｖａソ
ースコード１０は、Ｊａｖａコンパイラ１２によりコン
パイルされる。このコンパイルの結果が、バイトコード
１４である。このバイトコード１４は、ネットワーク３
を介してクライアント・コンピュータ５に送信される。
バイトコード１４は、クライアント・コンピュータ５内
のＷＷＷブラウザ（World Wide Web Browser）などに設
けられたＪａｖａ仮想マシン（Java VM）５２にとって
ネイティブ・コードであり、実際ハードウエア５５のＣ
ＰＵにて実行する場合には、Ｊａｖａインタープリタ５
４や、ＪａｖａＪＩＴコンパイラ５６を用いる。インタ
ープリタ５４は、実行時にバイトコード１４をデコード
し、命令ごとに用意される処理ルーチンを呼び出して実
行する。一方、ＪＩＴコンパイラ５６は、バイトコード
を事前にあるいは実行する直前にコンパイラを用いてマ
シン・コード５８に変換してそれをＣＰＵで実行する。

【００５１】以下、ＪＩＴコンパイラ５６の本発明に関
連する部分について説明する。

【００５２】Ａ．ループに対するバージョニングにより
不要な配列レンジ・チェックを除去する部分 バージョニングとは、コンパイル時に、（１）プログラ
ムのある部分のコードが実行される状態をいくつかに分
類し、（２）実行時にその状態を分類するためのチェッ
ク・コードと、それぞれの状態に対する、当該プログラ
ムのある部分の実行コードを生成する処理である。Ｊａ
ｖａで記述した例を表６及び表７に示す。表６中にはル
ープ変数ｉにより繰り返されるループが１つ存在する。
Ｊａｖａでは、配列のアクセスに対して、配列変数自体
がnullかどうかのテストと、配列インデックスが配列の
範囲（range：レンジ）内に収まっているかどうかのチ
ェックとを、実行時に行うことが要求される。このルー
プに対して、配列変数ａがnullでなく且つループ変数ｉ
（ここでは配列インデックス変数でもある）の変化の範
囲が配列ａの範囲内に収まるかどうかで、収まる場合と
収まらない場合の２つの場合に分類し、そのチェック・
コードと共に生成されたコードが表７のようになる。こ
のバージョニングにより、配列変数ａがnullではなく且
つループ変数ｉが配列ａの範囲内に収まる場合のコード
（then側のコード。但し、表７ではthenとは記されてい
ない。）では、配列アクセスに関するテストは必ず成功
するのでこれらのテストを除去することができる。一
方、配列変数ａがnullか又はループ変数ｉが配列の範囲
外をアクセスする可能性がある場合のコード（else側の
コード）では、a[i]への配列アクセスに対して、ａがnu
llであるか又はループ変数ｉが配列の範囲外をアクセス
する可能性があるので、それぞれに対するチェックを行
うコードを生成する。

【表６】

【表７】 public void f( int a[], int n ) { int i; if ( a != null && n <= a.length ){ // 配列aがnullでなく且つ // iが配列aの範囲内のみをアクセスする場合 for ( i=0; i<n; i++ ) { a[i] = a[i] * i; // a[i]のnullテストと範囲テストは不要 } }else{ // iが配列aの範囲外をアクセスする場合が存在する場合 for ( i=0; i<n; i++ ) { // check( a != null ); // check( i >= 0 ); // check( i < a.length ); a[i] = a[i] * i; // a[i]のnullテストと範囲テストが必要 } } }

【００５３】図２を用いて処理の概要を示しておく。ま
ず、各ベーシック・ブロックＢ内において、実行とは逆
順に、所定の条件に従ってＣ＿ＧＥＮ［Ｂ］を収集する
（ステップ１１０）。Ｃ＿ＧＥＮ［Ｂ］の情報は記憶装
置に記憶される。このＣ＿ＧＥＮ［Ｂ］は、ここでは配
列レンジ・チェックを必要とする配列アクセスにおける
配列インデックスの範囲の集合である。但し、後に詳し
く述べる所定の条件に従って収集されるものに限る。例
えば、配列ａで配列インデックスｖの場合には、配列ａ
の配列インデックスｖの下限ｌｂ（ａ）と上限ｕｂ
（ａ）とから、ｌｂ≦ｖ，ｕｂ（ａ）≧ｖであることが
確認されねばならない。よって、Ｃ＿ＧＥＮ［Ｂ］に
は、ｌｂ≦ｖ，ｕｂ（ａ）≧ｖが加えられる。なお、一
般的にはｌｂ（ａ）≦ｆ（ｖ），ｕｂ（ａ）≧ｆ（ｖ）
（ｆは関数）となる。このステップ１１０については後
に詳しく述べる。

【００５４】そして、深さ優先探索（Depth-First Sear
ch：ＤＦＳ）のポストオーダー・トラバーサル（Postor
der Traversal）の順番で、Ｃ＿ＧＥＮ［Ｂ］を必要な
修正を加えつつ伝播させ、各ベーシック・ブロックＢの
Ｃ＿ＩＮ［Ｂ］を生成する（ステップ１２０）。Ｃ＿Ｉ
Ｎ［Ｂ］の情報は記憶装置に記憶される。Ｃ＿ＩＮ
［Ｂ］は、ベーシック・ブロックＢの先頭における、配
列レンジ・チェックを必要とする配列アクセスにおける
配列インデックスの範囲の集合である。このステップ１
２０についても後に詳しく述べる。

【００５５】最後に、Ｃ＿ＩＮ［Ｂ］を用いて、ループ
の前にバージョニングのチェック・コードと、各実行状
態における実行コードとを生成する（ステップ１３
０）。チェック・コード及び実行コードは実行のため記
憶装置に記憶される。このようにして、ループ内の通常
必要とされる配列レンジ・チェックについて、ループの
先頭のチェック・コードにおいてその要否を可能な限り
判断してしまう。そうすると表７に示したように、チェ
ック・コードである３行目のｉｆ文の条件が満たされれ
ば、本発明が適用可能なものに限りループ内の配列レン
ジ・チェックは除去される。表７では全ての配列レンジ
・チェックが除去されている。一方、ｉｆ文の条件が満
たされなければ、必要な配列レンジ・チェックを実行す
る。ステップ１３０についても後に詳しく述べる。

【００５６】では、ステップ１１０から順に詳しく説明
する。ステップ１１０では、原則として配列インデック
ス又は配列ベースを変更する命令に関わる配列レンジ・
チェックを本ステップの対象外として取り扱いながら、
ベーシック・ブロックの先頭における、配列レンジ・チ
ェックの集合Ｃ＿ＧＥＮ［Ｂ］を、実行とは逆順に収集
する。但し、配列インデックス変数をｖ＝ｖ＋ｃ（ｃは
正又は負の定数）のように変更する場合には、本ステッ
プの対象外とはしないで、集合情報Ｃ＿ＧＥＮ［Ｂ］内
の配列インデックスの式ｆ（ｖ）をｆ（ｖ＋ｃ）として
再計算し、置き換える。以下にステップ１１０の擬似コ
ードを示す。

【表８】 for (各ベーシック・ブロックについて実行とは逆順に命令を取り出す){ switch(命令){ 配列アクセス命令: その配列レンジ・チェックＣに対して C_GEN[B] += Ｃ; break; 配列のベース変数 a の変更命令: for (全てのＣ∈ C_GEN[B]){ if (Ｃの中に変更された配列ベース a によるlb(a)又はub(a)が含まれる){ C_GEN[B] -= Ｃ; } } break; インデックス変数 v の変更命令: for (全てのＣ∈ C_GEN[B]){ if (Ｃは変更されたインデックス変数ｖ 又はｖの式 f(v) で構成される){ if (インデックス変数ｖが v = v + c (ｃは正又は負の定数：定数の加算又は減算)で変更される){ Ｃのｖを v + c、又はf(v)をf(v + c)として置き換える。 } else { C_GEN[B] -= Ｃ; } } } break; } }

【００５７】表８全体は各ベーシック・ブロックについ
て行われる。そして、各ベーシック・ブロックの各命令
ごとにｆｏｒループ内の処理が実施される。命令の取り
出し順番は実行順とは逆順となる。switch文は、取り出
した命令が、それ以下の条件（ここでは３つの条件）の
いずれかに該当する場合には、該当する条件の下に規定
された処理を実行するものである。この条件は、配列ア
クセス命令、配列ベース変数ａの変更命令、及びインデ
ックス変数ｖの変更命令である。配列アクセス命令の場
合には、その配列アクセス命令に対する配列レンジ・チ
ェックＣをＣ＿ＧＥＮ［Ｂ］に入れる。配列ベース変数
ａの変更命令の場合には、このベース変数ａに関連する
配列レンジ・チェックＣを本発明では取り扱うことがで
きないので、Ｃ＿ＧＥＮ［Ｂ］からＣを除去する処理を
実施する。インデックス変数ｖの変更の場合には、まず
Ｃ＿ＧＥＮ［Ｂ］内の各配列レンジ・チェックＣがその
変更された配列インデックス変数ｖに関連するか検査す
る。もし定数と配列インデックスの上限又は下限とによ
る検査であれば、インデックス変数ｖの変更操作はその
検査には影響が無い。そして、インデックス変数ｖの変
更命令が、定数の加算又は減算命令であるか判断する。
インデックス変数ｖの変更命令が、定数の加算又は減算
命令である場合には、Ｃ＿ＧＥＮ［Ｂ］内の配列レンジ
・チェックＣも、その定数の加算又は減算に従って、定
数の加算又は減算を実施する。本発明で取り扱い不可能
なインデックス変数ｖの変更を実施している場合には、
そのインデックス変数ｖに関連する配列レンジ・チェッ
クＣはＣ＿ＧＥＮ［Ｂ］から取り除かれる。

【００５８】次にステップ１２０の詳細について説明す
る。このステップ１２０では、上で収集したＣ＿ＧＥＮ
［Ｂ］を用いてＤＦＳのポスト・トラバーサルの順番、
すなわち後続のベーシック・ブロックが先に来るような
順番で全てのベーシック・ブロックについて、次の式を
一回実行する。Ｓ∈ Succ(B) であってＢとＳは同じル
ープ内という条件を満たす全てのＳについて、 C_OUT[B] = ∪ C_IN[S] C_IN[B] = C_GEN[B] ∪ backward(C_OUT[B], B) Succ(B)は、Ｂの直後に来る全てのベーシック・ブロッ
クの意味である。上の式は以下のことを示している。あ
るベーシック・ブロックＢの後端における、配列レンジ
・チェックの集合Ｃ＿ＯＵＴ［Ｂ］は、Ｓ∈ Succ(B)で
あってベーシック・ブロックＢとベーシック・ブロック
Ｓが同じループ内という条件を満たす全てのベーシック
・ブロックＳの先頭における、配列レンジ・チェックの
集合Ｃ＿ＩＮ［Ｓ］の和集合である。また、Ｃ＿ＯＵＴ
［Ｂ］は、後に述べる処理により、ベーシック・ブロッ
クＢにおいて行われる配列インデックスに対する変更に
応じて所定の修正が行われ、新たに集合backward(C_OUT
[B], B)となる。この集合backward(C_OUT[B], B)及び先
に求めたＣ＿ＧＥＮ［Ｂ］の和集合がＣ＿ＩＮ［Ｂ］と
なる。最終的に必要なのはこのＣ＿ＩＮ［Ｂ］である。
この処理を図３にまとめておく。

【００５９】では、backward(C_OUT[B], B)の処理を以
下の擬似コードを用いて説明する。

【表９】 backward(C_OUT[B], B){ T = 0; for (各配列レンジ・チェック C ∈ C_OUT[B]) { case C of lb <= v: case AFFECT(B, v) of unchanged: T = T ∪ { lb <= v } increment: if 加算する値 c が定数 then T = T ∪ { lb <= v + c } /* そうでなければTには入れない */ decrement: if 減算する値 c が定数 then T = T ∪ { lb <= v - c } else T = T ∪ { lb <= v } multiply: /* Tには入れない */ div > 1: T = T ∪ { lb <= v } div < 1: /* Tには入れない */ changed: /* Tには入れない */ end case v <= ub: case AFFECT(B, v) of unchanged: T = T ∪ { v <= ub } increment: if 加算する値 c が定数 then T = T ∪ { v + c <= ub } else T = T ∪ { v <= ub } decrement: if 減算する値 c が定数 then T = T ∪ { v - c <= ub } /* そうでなければTに入れない */ multiply: T = T ∪ { v <= ub } div > 1: /* Tには入れない */ div < 1: T = T ∪ { v <= ub } changed: /* Tには入れない */ end case lb <= f(v): case AFFECT(B, v) of unchanged: T = T ∪ { lb <= f(v) } increment: if f(v)が単調な関数であり且つ 加算する値 c が定数 then T = T ∪ { lb <= f( v + c ) } else if vが増加するとf(v) は減少する then T = T ∪ { lb <= f(v) } decrement: if f(v)が単調な関数であり且つ 減算する値 c が定数 then T = T ∪ { lb <= f( v - c ) } else if vが減少するとf(v)も減少する then T = T ∪ { lb <= f(v) } multiply, div < 1: if vが増加するとf(v)は減少する then T = T ∪ { lb <= f(v) } div > 1: if vが減少するとf(v)も減少する then T = T ∪ { lb <= f(v) } changed: /* Tには入れない */ end case f(v) <= ub: case AFFECT(B, v) of unchanged: T = T ∪ { f(v) <= ub } increment: if f(v)は単調な関数であり且つ 加算する値 c が定数 then T = T ∪ { f( v + c ) <= ub } else if vが増加するとf(v)も増加 then T = T ∪ { f(v) <= ub } decrement: if f(v)が単調な関数であり且つ 減算する値 c が定数 then T = T ∪ { f( v - c ) <= ub } else if vが減少するとf(v)は増加 then T = T ∪ { f(v) <= ub } multiply, div < 1: if vが増加するとf(v)も増加する then T = T ∪ { f(v) <= ub } div > 1: if vが減少するとf(v)は増加する then T = T ∪ { f(v) <= ub } changed: /* Tには入れない */ end case end case } return(T) }

【００６０】backward(C_OUT[B], B)の最終的な出力は
Ｔである。backward(C_OUT[B], B)はＣ＿ＯＵＴ［Ｂ］
に含まれる配列レンジ・チェックの内容により大きく４
つの部分に分けられる。すなわち、配列インデックス変
数ｖについて、ｌｂ≦ｖの場合及びｖ≦ｕｂの場合、配
列インデックスｆ（ｖ）について、ｌｂ≦ｆ（ｖ）の場
合及びｆ（ｖ）≦ｕｂの場合である。そして、それぞれ
の場合において、配列インデックス変数ｖに対する操作
（表９におけるAFFECT(B,v)。Ｂは処理を行っているベ
ーシック・ブロックを示している。）によってさらに場
合分けされる。以下、それぞれについて説明する。

【００６１】（１）ｌｂ≦ｖの場合 配列インデックス変数ｖに対する操作が何も無い場合
（unchanged）には、ｌｂ≦ｖをそのまま配列レンジ・
チェックの集合であるＴに入れる。なお、配列インデッ
クスが定数の場合にはこのunchangedに含まれる。配列
インデックス変数ｖを増加させる操作の場合（incremen
t）、加算する値ｃが定数であるかどうか判断する。も
し加算する値ｃが定数であれば、Ｔにはｌｂ≦ｖ＋ｃを
入れる。これ以外のｖを増加させる操作の場合には、本
発明では取り扱わないので、その配列レンジ・チェック
をＴには入れない。配列インデックス変数ｖを減少させ
る操作の場合（decrement）、減算する値ｃが定数であ
るかどうか判断する。もし減算する値ｃが定数であれ
ば、Ｔにｌｂ≦ｖ−ｃを入れる。これ以外のｖを減少さ
せる操作の場合には、ｌｂ≦ｖをＴに入れる。配列イン
デックス変数ｖが掛け算される場合（multiply）、本発
明では取り扱うことができないので、その配列レンジ・
チェックをＴには入れない。配列インデックス変数ｖが
１より大きな値で割り算される場合（div>1）には、ｌ
ｂ≦ｖをそのままＴに入れる。配列インデックス変数ｖ
が１より小さな値で割り算される場合（div<1）には、
本発明では取り扱うことができないので、その配列レン
ジ・チェックをＴには入れない。以上述べた操作以外の
操作の場合（changed）、本発明では取り扱うことがで
きないので、その配列レンジ・チェックをＴには入れな
い。

【００６２】（２）ｖ≦ｕｂの場合 配列インデックス変数ｖに対する操作が何も無い場合
（unchanged）には、Ｔにｖ≦ｕｂを入れる。配列イン
デックス変数ｖを増加させる操作の場合（incremen
t）、加算する値ｃが定数であるならばｖ＋ｃ≦ｕｂを
Ｔに入れる。一方、それ以外のｖを増加させる操作の場
合にはｖ≦ｕｂをＴに入れる。配列インデックス変数ｖ
を減少させる操作の場合（decrement）、減算する値ｃ
が定数であるならばｖ−ｃ≦ｕｂをＴに入れる。それ以
外のｖを減少させる操作の場合にはその配列レンジ・チ
ェックをＴには入れない。配列インデックス変数ｖが掛
け算される場合（multiply）、その配列レンジ・チェッ
クをＴには入れない。配列インデックス変数ｖを１より
大きい値で割り算する場合（div>1）、その配列レンジ
・チェックをＴには入れない。配列インデックス変数ｖ
が１より小さい値で割り算する場合（div<1）、ｖ≦ｕ
ｂをＴに入れる。以上述べた以外の操作の場合（change
d）、その配列レンジ・チェックをＴには入れない。

【００６３】（３）ｌｂ≦ｆ（ｖ）の場合 配列インデックス変数ｖに対する操作が何も無い場合
（unchanged）には、Ｔにｌｂ≦ｆ（ｖ）を入れる。配
列インデックス変数ｖを増加させる操作の場合（increm
ent）、ｆ（ｖ）が単調な関数(monotone）であって且つ
加算する値ｃが定数であるならば、ｌｂ≦ｆ（ｖ＋ｃ）
を入れる。また、そうでない場合であっても、ｖが増加
するとｆ（ｖ）が減少するような場合には、ｌｂ≦ｆ
（ｖ）をＴに入れる。配列インデックス変数ｖを減少さ
せる操作の場合（decrement）、ｆ（ｖ）が単調な関数
であって且つ減算する値ｃが定数であるならば、ｌｂ≦
ｆ（ｖ−ｃ）をＴに入れる。そうでない場合であって
も、ｖが減少するとｆ（ｖ）が減少する場合には、ｌｂ
≦ｆ（ｖ）をＴに入れる。配列インデックス変数ｖが掛
け算される場合及び１より小さい値で割り算される場合
（mutiply,div<1）、ｖが増加するとｆ（ｖ）が減少す
るならばｌｂ≦ｆ（ｖ）をＴに入れる。配列インデック
スｖを１より大きな値で割り算する場合（div>1）、ｌ
ｂ≦ｆ（ｖ）をＴに入れる。以上述べた以外の操作の場
合（changed）、その配列レンジ・チェックをＴには入
れない。

【００６４】（４）ｆ（ｖ）≦ｕｂの場合 配列インデックス変数ｖに対する操作が何もない場合
（unchanged）には、ｆ（ｖ）≦ｕｂをＴに入れる。配
列インデックス変数ｖを増加させる操作の場合（increm
ent）、ｆ（ｖ）が単調な関数であって且つ加算する値
ｃが定数ならば、ｆ（ｖ＋ｃ）≦ｕｂをＴに入れる。ま
た、そうでない場合であっても、ｖが増加するとｆ
（ｖ）が増加する場合には、ｆ（ｖ）≦ｕｂをＴに入れ
る。配列インデックス変数ｖを減少させる操作の場合、
ｆ（ｖ）が単調な関数であって且つ減算する値ｃが定数
ならば、ｆ（ｖ−ｃ）≦ｕｂをＴに入れる。そうでない
場合であっても、ｖが減少するとｆ（ｖ）は増加するな
らば、ｆ（ｖ）≦ｕｂをＴに入れる。配列インデックス
変数ｖを掛け算する場合及び１より小さな値で割り算す
る場合（multiply,div <1）、ｖが増加するとｆ（ｖ）
も増加するならば、ｆ（ｖ）≦ｕｂをＴに入れる。配列
インデックスｖを１より大きな値で割り算する場合（di
v>1）、ｆ（ｖ）≦ｕｂをＴに入れる。以上述べた以外
の操作の場合（unchanged）、その配列レンジ・チェッ
クをＴに入れない。

【００６５】次にステップ１３０を詳細に述べる。ルー
プのバージョニングをする場合には、ループの先頭（エ
ントリポイント）におけるＣ＿ＩＮ［Ｂ］及びループ変
数の取り得る範囲から、配列レンジ・チェックが不要に
なる条件を導き出す。例えば、ループ変数がｉであっ
て、取り得る範囲が１以上ｎ未満であることが分かれ
ば、ｕｂ（ａ）についてはｉ＝ｎ−１である場合につい
てチェックし、ｌｂ（ａ）についてはｉ＝１であるとし
てチェックする。なお、本発明で取扱い可能なものにつ
いて配列レンジ・チェックを不要にするということであ
って、本発明で取扱い不可能なものについては上の条件
に含めない。この条件に基づきチェック・コードをルー
プの先頭に生成し、配列レンジ・チェック不要のループ
処理のためのコード、及び配列レンジ・チェックが必要
なループ処理のためのコードをそれぞれ生成する。

【００６６】なお、Ａ．の処理とＣ．の処理を組み合わ
せて行う場合には、以下のような処理を行っておく。バ
ージョンニングを行うループに対してバージョニング前
のエントリポイントをＢ、同ループのバージョニング後
のバージョニング条件を満たす方のエントリポイントを
Ｂ２とした時に、Ｃ＿ＩＮ［Ｂ］をＶＥＲＳＩＯＮ［Ｂ
２］にコピーする。ループのエントリポイント以外のＶ
ＥＲＳＩＯＮ＿ＯＲ［Ｂ２］はφとする。

【００６７】では、表１０に示すサンプル・プログラム
に、以上説明した処理を実施した場合の例を説明する。

【表１０】 なお、BBはベーシック・ブロックを表し、その後の番号
はベーシック・ブロックの番号である。

【００６８】最初に、図２のステップ１１０を各ベーシ
ック・ブロックにつき実行する。BB1は配列アクセスが
存在しないのでＣ＿ＧＥＮ［BB1］は空である。ステッ
プ１１０は実行とは逆順に行われるため、最初にＣ＿Ｇ
ＥＮ［BB2］に含まれるのは、ｌｂ（ａ）≦ｉ−２及び
ｉ≦ｕｂ（ａ）である。次の命令はｉ＋＋でｉ＝ｉ＋１
が実行されるので、配列インデックスの定数の加算であ
る。よって、ｌｂ（ａ）≦ｉ−２及びｉ≦ｕｂ（ａ）の
ｉを＋１する。すなわち、ｌｂ（ａ）≦（ｉ＋１）−２
＝ｉ−１及びｉ＋１≦ｕｂ（ａ）がＣ＿ＧＥＮ［BB2］
に入力される。

【００６９】Ｃ＿ＧＥＮ［BB3］に最初に含まれるの
は、ｌｂ（ａ）≦ｉ−２、ｉ≦ｕｂ（ａ）、ｌｂ（ａ）
≦５及び５≦ｕｂ（ａ）である。実行とは逆順で次の命
令ｉ＋＋によりＣ＿ＧＥＮ［BB3］を変更すると、ｌｂ
（ａ）≦ｉ−１、ｉ＋１≦ｕｂ（ａ）、ｌｂ（ａ）≦５
及び５≦ｕｂ（ａ）となる。同様にすると、Ｃ＿ＧＥＮ
［BB4］はｌｂ（ａ）≦ｉ−２、ｉ＋１≦ｕｂ（ａ）と
なる。以下にまとめておく。

【００７０】例えば、配列レンジ・チェックは以下のよ
うに記憶装置に記憶される。すなわち、（１）配列ベー
ス（２）配列インデックスのうちインデックス変数を含
む項（３）配列インデックスの最大定数オフセット及び
（４）配列インデックスの最小定数オフセットである。
Ｃ＿ＧＥＮ［BB2］の場合、最初はａ［ｉ］が出現する
ので、（１）ａ（２）ｉ（３）０（４）０が記憶され
る。次いでａ［ｉ−１］が出現するので、（１）ａ
（２）ｉ（３）０（４）−１となる。最後にａ［ｉ−
２］が出現するので、（１）ａ（２）ｉ（３）０（４）
−２となる。ところが、実行とは逆順に次の命令を見る
とｉ＋＋であるから、（２）のｉがｉ＋１になるが、こ
のような変更の結果は（３）及び（４）に反映されて、
（１）ａ（２）ｉ（３）＋１（４）−１が記憶装置に記
憶される。

【００７１】同様にして、Ｃ＿ＧＥＮ［BB3］の場合、
（１）ａ（２）ｉ（３）０（４）０から（１）ａ（２）
ｉ（３）０（４）−１となり、（１）ａ（２）ｉ（３）
０（４）−２に変化し、さらに（１）ａ（２）ｉ（３）
１（４）−１となる。また、（１）ａ（２）null（３）
５（４）５というデータも記憶装置に記憶される。Ｃ＿
ＧＥＮ［BB4］の場合には、（１）ａ（２）ｉ（３）０
（４）０から（１）ａ（２）ｉ（３）０（４）−１とな
り、（１）ａ（２）ｉ（３）０（４）−２を経て（１）
ａ（２）ｉ（３）０（４）−３に変化する。そして、ｉ
＋＋により（２）の変更が（３）及び（４）に反映され
て（１）ａ（２）ｉ（３）＋１（４）−２が記憶装置に
記憶される。

【００７２】次に、表１０のフローグラフを図４に示
す。BB2の先頭がループのエントリポイントになる。Ｓ
∈Succ(B)は、Ｂの直後のベーシック・ブロックである
から、BB1にとってはBB2、BB2にとってはBB3及びBB4、B
B3にとってはBB4、BB4にとってはBB5及びBB2、BB5にと
っては無しである。但し、本発明では、Ｓ∈Succ(B)で
あってＢとＳは同じループ内という条件を満たさなけれ
ばならないので、BB1には該当するベーシック・ブロッ
クはない。またBB4にとってはBB5は同じループ内ではな
いのでBB2のみが対象となる。以下Ｓ∈Succ(B)であって
ＢとＳは同じループ内という条件を満たすベーシック・
ブロックをまとめておく。 BB1: φ BB2: BB3, BB4 BB3: BB4 BB4: BB2 BB5: φ

【００７３】図２のステップ１２０ではＤＦＳのポスト
オーダー・トラバーサルの順番にＣ＿ＩＮ［Ｂ］を求め
る。表１０の例ではBB5、BB4、BB3、BB2、BB1の順番で
１回図３の処理が実施される。まず、BB5については、
先に示した条件を満たすベーシック・ブロックＳが空で
あるからＣ＿ＯＵＴ［BB5］も空であり、Ｃ＿ＧＥＮ［B
B5］も空であるから、Ｃ＿ＩＮ［BB5］も空である。BB4
について先に示した条件を満たすベーシック・ブロック
はBB2であるが、Ｃ＿ＩＮ［BB2］はまだ計算されていな
いので、Ｃ＿ＯＵＴ［BB4］は空となる。しかし、Ｃ＿
ＧＥＮ［BB4］は上で述べたようにlb(a) ≦ i-2, i+1
≦ ub(a)であるから、Ｃ＿ＩＮ［BB4］はlb(a) <= i-2,
i+1 <= ub(a)となる（先に示した記憶方法の場合、
（１）ａ（２）ｉ（３）＋１（４）−２）。

【００７４】BB3について先に示した条件を満たすベー
シック・ブロックはBB4であるから、Ｃ＿ＯＵＴ［BB3]
＝Ｃ＿ＩＮ［BB4］となる。backward（C_OUT[BB3], BB
3）を次に求める。BB3でなされている配列インデックス
変数ｉの操作は１（定数）の加算であるから、Ｃ＿ＯＵ
Ｔ［BB3］内のlb(a) ≦ i-2, i+1 ≦ ub(a)のｉはｉ＋
１で置換される。よって、Ｔ＝｛lb(a) ≦ i-1, i+2 ≦
ub(a)}となる（先に示した記憶方法の場合、（１）ａ
（２）ｉ（３）＋２（４）−１）。さらに、Ｃ＿ＧＥＮ
［BB3］はlb(a) ≦ i-1, i+1 ≦ ub(a)，lb(a) ≦ 5, 5
≦ ub(a)であるから、Ｃ＿ＧＥＮ［BB3］とＴの和集合
Ｃ＿ＩＮ［BB3］は、lb(a) ≦ i-1, i+2≦ ub(a)、lb
(a) ≦ 5, 5 ≦ ub(a)となる（先に示した記憶方法の場
合、（１）ａ（２）null（３）５（４）５，（１）ａ
（２）ｉ（３）＋２（４）−１）。

【００７５】BB2について先に示した条件を満たすベー
シック・ブロックはBB3及びBB4であるから、Ｃ＿ＯＵＴ
［BB2］＝Ｃ＿ＩＮ［BB3］∪Ｃ＿ＩＮ［BB4］となる。
但し、Ｃ＿ＩＮ［BB4］は空であるから、Ｃ＿ＯＵＴ［B
B2］＝Ｃ＿ＩＮ［BB3］となる。また、backward(C_OUT
[BB2], BB2)を次に求める。BB2でなされている配列イン
デックス変数ｉの操作は１（定数）の加算であるから、
Ｃ＿ＯＵＴ［BB2］内のlb(a) ≦ i-1, i+2 ≦ ub(a)、l
b(a) ≦ 5, 5 ≦ ub(a)のｉをｉ＋１で置換する。すな
わち、Ｔ＝｛lb(a) ≦ i, i+3 ≦ ub(a)、lb(a) ≦ 5,
5 ≦ ub(a)｝となる（先に示した記憶方法の場合、
（１）ａ（２）null（３）５（４）５，（１）ａ（２）
ｉ（３）＋３（４）０）。そしてＣ＿ＧＥＮ［BB2］
（＝lb(a) ≦ i-1, i+1 ≦ ub(a)）とＴとの和集合Ｃ＿
ＩＮ［BB2］をとると、lb(a) ≦ i-1, i+3 ≦ ub(a)、l
b(a) ≦ 5, 5 ≦ ub(a)となる（先に示した記憶方法の
場合、（１）ａ（２）null（３）５（４）５，（１）ａ
（２）ｉ（３）＋３（４）−１）。

【００７６】BB1について先に示した条件を満たすベー
シック・ブロックはなく且つＣ＿ＧＥＮ［BB1］も空で
あるから、Ｃ＿ＯＵＴ［BB1］及びＣ＿ＩＮ［BB1］は共
に空になる。以上を下にまとめておく。

【００７７】次に、ループのエントリポイントであるBB
2の先頭の情報Ｃ＿ＩＮ［BB2］を用いて、バージョニン
グのためのチェック・コードの生成を行う。ここでは、
Ｃ＿ＩＮ［BB2］＝｛lb(a) <= i-1, i+3 <= ub(a)，lb
(a) <= 5, 5 <= ub(a)｝である。さらに、表１０のBB1
の最初のラインでｉ＝１、BB4の最後のラインでｉ＜ｎ
であることが示されているため、１≦ｉ≦ｎ−１である
ことが分かる。よって、１≦ｎ−１であって、ｉが最小
であると１であるからｌｂ（ａ）≦１−１＝０、ｉが最
大であるとｎ−１であるから（ｎ−１）＋３＝ｎ＋２≦
ｕｂ（ａ）、５≦ｕｂ（ａ）となる。なお、ｌｂ（ａ）
≦５は、ｌｂ（ａ）≦０に含まれる条件である。

【００７８】そして、以上の条件が満たされれば、配列
レンジ・チェックは不要となる。一方、以上の条件が満
たされなければ、配列レンジ・チェックが必要になる。
配列レンジ・チェックが必要となる場合の実行コード
は、表１０に、必要な配列レンジ・チェックを行うコー
ドを付加する形になる。付加するコードは従来技術によ
る方法で生成してもよいし、後に述べる本発明の方法を
使用して付加することも可能である。以下、表１１に表
１０の処理結果を示すが、ここでは配列レンジ・チェッ
クが必要な部分については何等の特別な処理を実施して
いない状況を示す。表１１は本発明の処理結果を分かり
やすく示したものであって、実際は表１１のような実行
可能なコードが生成される。

【表１１】 i = 1; t = 0; if (1 <= n-1 && lb(a) <= 0 && /* lb(a)が０以下の言語はこのチェックは必要ない */ n+2 <= ub(a) && 5 <= ub(a)){ /* 条件を満たす時 */ do { /* BB2の先頭の点でC_IN[BB2]内の集合要素についてのチェック check(lb(a) <= i-1); check(i+3 <= ub(a)); check(lb(a) <= 5); check(5 <= ub(a)); が行われているものとして扱い、挿入及び除去を行う。 */ i++; t += a[i] + a[i-1] + a[i-2]; /* チェック不要 */ if (t < 0) { i++; t += a[i] + a[i-1] + a[i-2] + a[5]; /* チェック不要 */ } i++; t += a[i] + a[i-1] + a[i-2] + a[i-3]; /* チェック不要 */ } while(i < n); } else { /* 条件を満たさない時 */ do { i++; check(lb(a) <= i-2); check(i <= ub(a)); t += a[i] + a[i-1] + a[i-2]; if (t < 0) { i++; check(i <= ub(a)); check(lb(a) <= i-2); check(lb(a) <= 5); /* lb(a)が５以下の言語はこのチェックは必要ない */ check(5 <= ub(a)); t += a[i] + a[i-1] + a[i-2] + a[5]; } i++; check(lb(a)<=i-3) check(i<=ub(a)) t += a[i] + a[i-1] + a[i-2] + a[i-3]; } while(i < n); } コメント文に示されているように、ｌｂ（ａ）が５以下
であることが明らかな言語の場合には必要のない配列レ
ンジ・チェックも示してある。例えばＪａｖａはｌｂ
（ａ）が０であるから、check(lb(a) <= 5)は不要であ
る。

【００７９】Ｂ．データ・フロー解析を実行順序とは逆
順に行って配列レンジ・チェックを最適化する部分 本処理の概要を図５に示す。まず、各ベーシック・ブロ
ック内において、実行とは逆順に、所定の条件に従って
Ｃ＿ＧＥＮ［Ｂ］を収集する（ステップ２１０）。収集
結果は、記憶装置に記憶される。所定の条件は以下に説
明するが図２のステップ１１０とは異なる。しかし、Ｃ
＿ＧＥＮ［Ｂ］の意味は同じである。そして、プログラ
ムにおけるデータ・フロー解析の順番で、処理中のベー
シック・ブロック中に副作用を生じるような命令が含ま
れているか否かの情報を用い且つ第２の条件に従ってＣ
＿ＧＥＮ［Ｂ］を伝搬させ、各ベーシック・ブロックに
おけるＣ＿ＯＵＴ［Ｂ］を生成する（ステップ２２
０）。Ｃ＿ＯＵＴ［Ｂ］は記憶装置に記憶される。第２
の条件に関連してＡ．におけるBackward処理を実施す
る。最後に、各ベーシック・ブロックにおいて、Ｃ＿Ｏ
ＵＴ［Ｂ］を第３の条件に従って修正しつつ実行とは逆
順に各命令を辿り、Ｃ＿ＯＵＴ［Ｂ］を用いて配列レン
ジ・チェックのためのコードを生成する（ステップ２３
０）。生成されたコードは記憶装置に記憶される。以
下、各ステップについて詳しく説明する。

【００８０】ステップ２１０では、例外を発生させる配
列レンジ・チェックがそれより前に移動させることによ
って副作用を生じるような命令が存在する場合にはＣ＿
ＧＥＮ［Ｂ］を空にし、且つ配列インデックス変数を正
又は負の定数の加算以外で変更する場合には変更された
配列インデックス変数に関連する配列レンジ・チェック
を取り扱わないものとして、ベーシック・ブロック中で
必要とされる配列レンジ・チェックの集合情報Ｃ＿ＧＥ
Ｎ［Ｂ］を実行とは逆順で求める。なお、副作用とは、
移動前と後では実行結果が異なる、すなわちその命令が
実行されなくなるという結果をもたらすことを言う。こ
の副作用を生じるような命令の例としては、例外（Exce
ption）を発生する命令、ヒープ領域への書き込み命
令、関数呼び出し、Ｊａｖａではトライ領域（Try Regi
on）内でローカル変数の書き込み命令のようなチェック
を移動することにより副作用を生じる命令等、である。
以下にステップ２１０の擬似コードを示す。

【表１２】 for (各ベーシック・ブロックについて実行とは逆順に命令を取り出す){ switch(命令){ 配列アクセス: 配列レンジ・チェックＣに対して C_GEN[B] += Ｃ; break; 配列のベース変数 a の変更: for (全てのＣ∈ C_GEN[B]){ if (Ｃの中に変更された配列ベース a による lb(a)またはub(a)が含まれる){ C_GEN[B] -= Ｃ; } } break; インデックス v の変更: for (全てのＣ∈ C_GEN[B]){ if (Ｃは変更されたインデックス v 又は v の式 f(v) で構成される){ if (インデックス v が v = v + c (cは定数)で変更される){ Ｃの v を v + c、又はf(v)をf(v + c)として置き換える。 } else { C_GEN[B] -= Ｃ; } } } break; 例外を発生させる配列レンジ・チェックをそれより前に移動 することにより副作用を生じるような命令: C_GEN[B] = φ; break; } }

【００８１】例外を発生させる配列レンジ・チェックが
それより前に移動することにより副作用を生じるような
命令（以下副作用命令と呼ぶ）の場合に、Ｃ＿ＧＥＮ
［Ｂ］を空φにする場合が追加されたことを除き、表８
に示された処理と同じである。このような条件が満たさ
れる場合には、配列レンジ・チェックを移動させること
ができないので、Ｃ＿ＧＥＮ［Ｂ］を空にする。

【００８２】ステップ２２０では、このＣ＿ＧＥＮ
［Ｂ］を用いて次の式によるデータフロー解析（Data-f
low Analysis）を実施し、Ｃ＿ＯＵＴ［Ｂ］を生成す
る。

【表１３】 Ｂが終端のベーシック・ブロックでない場合には、Ｓ∈Succ(B)に対して、 C_OUT[B] = ∩ C_IN[S] 一方、Ｂが終端のベーシック・ブロックである場合には、 C_OUT[B] = φ if (Bの中に副作用命令がある）{ C_IN[B] = C_GEN[B] } else { C_IN[B] = C_GEN[B] ∪ backward(C_OUT[B], B) } なお、backward(C_OUT[B],B)は表９に示したものと同じ
である。表１３は、Ｃ＿ＯＵＴ［Ｂ］を求める際には、
Ｂが終端でない場合にはＣ＿ＩＮ［Ｓ］の積集合を計算
し、Ｂが終端の場合にはＣ＿ＯＵＴ［Ｂ］を空にする必
要があることを示している。Ｓは上でも述べたがＢの直
後の全てのベーシック・ブロックである。Ｃ＿ＩＮ
［Ｂ］は、Ｂの中に副作用を生ずる命令が存在する場合
にはＣ＿ＩＮ［Ｂ］＝Ｃ＿ＧＥＮ［Ｂ］により、また副
作用を生ずる命令が存在しない場合にはＣ＿ＩＮ［Ｂ］
＝Ｃ＿ＧＥＮ［Ｂ］∪ backward(C_OUT[B], B)により求
められる。以上を図６にまとめておく。

【００８３】ステップ２３０はＣ＿ＯＵＴ［Ｂ］を基に
配列レンジ・チェックのためのコードを生成する処理で
ある。以下に擬似コードを示す。

【表１４】 for (各ベーシック・ブロックについて実行とは逆順に命令を取り出す){ switch(命令){ 配列アクセス: その配列レンジ・チェックＣに対して exist = FALSE; for (全てのＣ'∈ C_OUT[B]){ if (Ｃ ⊆ Ｃ'){ exist = TRUE; if (Ｃ ⊂ Ｃ') { ＣをＣ'として配列レンジ・チェックのコードを生成。 break; } } } if (!exist){ C_OUT[B] += Ｃ; Ｃの配列レンジ・チェックのコードを生成。 break; } 配列のベース変数 a の変更: for (全てのＣ∈ C_OUT[B]){ if (Ｃの中に変更された配列ベース a による lb(a)またはub(a)が含まれる){ C_OUT[B] -= Ｃ; } } break; インデックス v の変更: for (全てのＣ∈ C_OUT[B]){ if (Ｃは変更されたインデックス v 又は v の式 f(v) で構成される){ if (インデックス v が i = i + c(cは正又は負の定数) で変更される){ Ｃの v を v + c、又はf(v)をf(v + c)として置換。 } else { C_OUT[B] -= Ｃ; } } } break; 副作用命令: C_OUT[B] = φ; break; } }

【００８４】表１４は表１２に似ているが、最初のswit
chの条件である、取り出した命令が配列アクセスである
場合の処理内容が異なる。まず、existをFALSEに初期化
した後、Ｃ＿ＯＵＴ［Ｂ］内の全てのＣ'について処理
中の配列アクセスに対する配列レンジ・チェックＣを検
査する。そして、Ｃ⊆Ｃ'であるならば、existをTRUEに
して、ＣがＣ＿ＯＵＴ［Ｂ］と重複関係があることを記
録する。そして、さらにＣ⊂Ｃ'であるならば（配列レ
ンジ・チェックＣの範囲が、Ｃ＿ＯＵＴ［Ｂ］内のＣ'
の範囲より狭い場合）、ここでＣの配列チェックをする
よりもＣ'の方が好ましいのでＣをＣ'として配列レンジ
・チェックのためのコードを生成する。一方、いずれの
Ｃ'についてもＣ⊆Ｃ'でなければ、existはTRUEになら
ないので、このＣにて配列レンジ・チェックのためのコ
ードを生成する。但し、ここでＣについて配列レンジ・
チェックのためのコードを生成するので、以降同じ範囲
の配列レンジ・チェックを行わないようにするため、Ｃ
をＣ＿ＯＵＴ［Ｂ］に加える。

【００８５】以上のようにして配列レンジ・チェックが
最適化される。表１０の例に本発明の最適化処理を施し
た例を以下に示しておく。Ｃ＿ＧＥＮ［Ｂ］は、表１０
が副作用命令を含まないので、Ａ．における処理結果と
同じである。一方、Ｃ＿ＯＵＴ［Ｂ］はステップ２２０
が異なるため、異なる。BB5は、終端ベーシック・ブロ
ックであるからＣ＿ＯＵＴ［BB5］は空である。そし
て、Ｃ＿ＧＥＮ［BB5］も空であるからＣ＿ＩＮ［BB5］
も空である。BB4のＣ＿ＯＵＴ［BB4］も、C_OUT[B] =
∩ C_IN[S]の要件から空になる。しかし、Ｃ＿ＧＥＮ
［BB4］がlb(a) <= i-2, i+1 <= ub(a)であるから、Ｃ
＿ＩＮ［BB4］もlb(a) <= i-2, i+1 <= ub(a)となる。
（１）配列ベース（２）配列インデックスのうちインデ
ックス変数を含む項（３）配列インデックスの最大定数
オフセット及び（４）配列インデックスの最小定数オフ
セットのように記憶装置に記憶する場合には、（１）ａ
（２）ｉ（３）＋１（４）−２となる。

【００８６】Ｃ＿ＯＵＴ［BB3］はＣ＿ＩＮ［BB4］のみ
から得られるので、Ｃ＿ＯＵＴ［BB3］もlb(a) <= i-2,
i+1 <= ub(a)となる。一方、Ｃ＿ＩＮ［BB3］はＣ＿Ｇ
ＥＮ［BB3］とbackward(C_OUT[BB3], BB3)から得られ
る。BB3には１（定数）の加算が含まれているので、lb
(a) <= i-2, i+1 <= ub(a)は、Ｔ＝｛lb(a) <= i-1, i+
2 <= ub(a)｝に修正される（先に示した記憶方法では、
（１）ａ（２）ｉ（３）＋２（４）−１）。Ｃ＿ＧＥＮ
［BB3］がlb(a) <= i-1, i+1 <= ub(a)，lb(a) <= 5, 5
<= ub(a)であるから、最終的にＣ＿ＩＮ［BB3］は、lb
(a) <= i-1, i+2<= ub(a)，lb(a) <= 5, 5 <= ub(a)と
なる（先に示した記憶方法では（１）ａ（２）ｉ（３）
＋２（４）−１，（１）ａ（２）null（３）５（４）
５）。

【００８７】Ｃ＿ＯＵＴ［BB2］はＣ＿ＩＮ［BB4］及び
Ｃ＿ＩＮ［BB3］の積集合から得られる。Ｃ＿ＩＮ［BB
4］はlb(a) <= i-2, i+1 <= ub(a)、Ｃ＿ＩＮ［BB3］は
lb(a) <= i-1, i+2 <= ub(a)，lb(a) <= 5, 5 <= ub(a)
であるから、Ｃ＿ＯＵＴ［BB2］はlb(a) <= i-1, i+1 <
= ub(a)となる（先に示した記憶方法では（１）ａ
（２）ｉ（３）＋１（４）ー１）。一方、Ｃ＿ＩＮ［BB
2］は、Ｃ＿ＧＥＮ［BB2］とbackward(C_OUT[BB2]，BB
2)の和集合となる。backward(C_OUT[BB2]，BB2)は、BB2
に１（定数）の加算操作を含むので、lb(a) <= i, i+2
<= ub(a)となる（先に示した記憶方法では（１）ａ
（２）ｉ（３）＋２（４）０）。Ｃ＿ＧＥＮ［BB2］はl
b(a) <= i-1, i+1 <= ub(a)であるから、最終的にＣ＿
ＩＮ［BB2］はlb(a) <= i-1, i+2 <= ub(a)となる（先
に示した記憶方法では（１）ａ（２）ｉ（３）＋２
（４）−１）。

【００８８】Ｃ＿ＯＵＴ［BB1］はＣ＿ＩＮ［BB2］から
得られる。よって、Ｃ＿ＯＵＴ［BB1］はlb(a) <= i-1,
i+2 <= ub(a)となる（先に示した記憶方法では（１）
ａ（２）ｉ（３）＋２（４）−１）。Ｃ＿ＩＮ［BB1］
はＣ＿ＧＥＮ［BB1］とbackward(C_OUT[BB1], BB1)の和
集合になる。しかし、Ｃ＿ＧＥＮ［BB1］は空であり、B
ackward処理の中でBB1にはｉの定数代入（ｉ＝０）があ
るので、Ｃ＿ＯＵＴ［BB1］の全てのＣは除去されてＴ
は空になる。よって、Ｃ＿ＩＮ［BB1］は空となる。以
下、上の処理結果をまとめておく。

【００８９】次にステップ２３０の処理を実施する。ま
ず、Ｃ＿ＯＵＴ［BB1］を用いてBB1を処理する。しか
し、BB1には配列アクセスがないので、配列レンジ・チ
ェックのためのコードは生成されない。次にＣ＿ＯＵＴ
［BB2］を用いてBB2を処理する。BB2には配列アクセス
が存在する。本発明適用前には、check(i<=ub(a))及びc
heck(i-2>=lb(a))が必要であった。しかし、Ｃ＿ＯＵＴ
［BB2］のi+1<= ub(a)の方がi<=ub(a)よりも広い範囲を
カバーすることになるので、check(i<=ub(a))はcheck(i
+1<=ub(a))で置換される。また、Ｃ＿ＯＵＴ［BB3］を
用いてBB3を処理する場合、本発明適用前には、check(i
<= ub(a))、check(lb(a) <= i-2)、check(lb(a) <=
5)、及びcheck(5 <= ub(a))が必要であった。しかし、
Ｃ＿ＯＵＴ［BB3］内のi+1 <= ub(a)はcheck(i <= ub
(a))より広い範囲をカバーするので、このcheck(i <= u
b(a))をcheck(i+1 <= ub(a))に置換してコードを生成す
る。BB3には配列インデックス変数を定数で加算する操
作が含まれるが、実行とは逆順でその操作の後に配列ア
クセスが存在しないので影響はない。次にＣ＿ＯＵＴ
［BB4］を用いてBB4を処理するが、Ｃ＿ＯＵＴ［BB4］
が空であるから、本発明の適用前と同じ状態になる。BB
5についても処理は必要ない。以下表１５に表１０に対
し本処理を実施した結果を示す。なお、表１５は本発明
の適用結果がわかるように示しているものであって、現
実には実行可能コードが生成される。

【表１５】 i = 1; t = 0; do { i++; check(lb(a) <= i-2); check(i+1 <= ub(a)); /*check(i <= ub(a))の置換後*/ t += a[i] + a[i-1] + a[i-2]; if (t < 0) { i++; check(lb(a) <= i-2); check(i+1 <= ub(a)); /* check(i <= ub(a))の置換後*/ check(lb(a) <= 5); /* lb(a)が５以下の言語はこのチェックは必要ない */ check(5 <= ub(a)); t += a[i] + a[i-1] + a[i-2] + a[5]; } i++; check(lb(a) <= i-3); check(i <= ub(a)); t += a[i] + a[i-1] + a[i-2] + a[i-3]; } while(i < n);

【００９０】Ｃ．データ・フロー解析を実行順に行って
配列レンジ・チェック済の情報を取得し、この情報から
不要な配列レンジ・チェックを除去する部分 図７に本処理の概要を示す。まず、各ベーシック・ブロ
ック内において、実行の順番で、所定の条件に従ってチ
ェック済みとして取り扱われる配列レンジ・チェックの
集合Ｃ＿ＧＥＮ［Ｂ］を収集する（ステップ３１０）。
このＣ＿ＧＥＮ［Ｂ］は記憶装置に記憶される。そし
て、プログラムのデータフロー解析の順番で、Ｃ＿ＧＥ
Ｎ［Ｂ］を第２の条件で修正しつつ伝搬させ、各ベーシ
ック・ブロックの先頭においてチェック済みとして取り
扱われる配列レンジ・チェックの集合Ｃ＿ＩＮ［Ｂ］を
生成する（ステップ３２０）。Ｃ＿ＩＮ［Ｂ］は記憶装
置に記憶される。そして、最後に、各ベーシック・ブロ
ック内において、実行順番に各命令をたどり、Ｃ＿ＩＮ
［Ｂ］を第３の条件で修正し、Ｃ＿ＩＮ［Ｂ］を用いて
配列レンジ・チェックを除去する（ステップ３３０）。

【００９１】ではステップ３１０について説明する。こ
こでは配列ベースを変更する命令を本発明の対象外とす
る。一方、配列インデックス変数の正又は負の定数によ
る加算命令が含まれていても、当該配列インデックス変
数に関連する配列レンジ・チェックは本発明の対象であ
るとして取り扱う。それ以外の変更命令に関連する配列
レンジ・チェックは本発明の対象外である。このような
条件の下、ベーシック・ブロック内でチェック済みとし
て取り扱われる配列レンジ・チェックの集合Ｃ＿ＧＥＮ
［Ｂ］を実行順に収集する。なお、配列インデックス変
数ｉをｉ＋ｃ（ｃは正又は負の定数）のように変更する
場合には、Ｃ＿ＧＥＮ［Ｂ］の配列インデックスの式ｆ
（ｉ）をｆ（ｉ−ｃ）として配列レンジ・チェックの情
報を更新する。以下、この処理の擬似コードを示す。

【表１６】 for (各ベーシック・ブロックについて実行順に命令を取り出す){ switch(命令){ 配列アクセス命令: その配列レンジ・チェックＣに対し C_GEN[B] += Ｃ; C_GEN[B] += Ｃの拡張; break; 配列のベース変数 a の変更: for (全てのＣ∈ C_GEN[B]){ if (Ｃの中に変更された配列ベース a による lb(a)またはub(a)が含まれる){ C_GEN[B] -= Ｃ; } } break; インデックス v の変更: for (全てのＣ∈ C_GEN[B]){ if (Ｃは変更されたインデックス v 又は v の式 f(v) で構成される){ if (インデックス v が i = i + c (cは正又は負の定数)で変更される){ Ｃ内の v を v - c、又はf(v)をf(v - c)として置き換える。 } else { C_GEN[B] -= Ｃ; } } } break; } }

【００９２】上で述べたＡ．及びＢ．とは異なり、ステ
ップ３１０では実行の順番で各ベーシック・ブロックの
命令を走査していく。そして、配列アクセス命令である
場合には、当該配列アクセスの配列レンジ・チェックＣ
をＣ＿ＧＥＮ［Ｂ］に入れる。可能であれば、Ｃの拡張
についてもＣ＿ＧＥＮ［Ｂ］に入れる。この拡張は以下
のようなものである。 （１）配列インデックスの最小定数オフセット値及び最
大定数オフセット値及び配列の下限から計算される範囲
の配列レンジ・チェック。すなわち、（配列の下限，配
列の下限＋（最大定数オフセット値−最小定数オフセッ
ト値））の定数インデックスの範囲がチェック済みであ
るとされる。例えば、Ｊａｖａ言語でa[i-1]、a[i+1]が
配列レンジ・チェック済みである場合には、定数インデ
ックスに関してa[0]からa[2]もチェック済みであるとし
てＣ＿ＧＥＮ［Ｂ］に加える。 （２）配列の下限及び配列インデックス変数の下限値及
び上限値から計算される範囲の配列レンジ・チェック次
のいずれかの条件を満たし、下限値又は上限値を基に計
算したインデックスの式の値が配列の下限以上の値をと
る時に、（配列の下限，変数の下限値又は上限値を基に
計算したインデックスの式の値）の定数インデックスの
範囲がチェック済みであるとされる。 条件： インデックスの式が単調増加し、インデックス変数の下
限値が分かるとき インデックスの式が単調減少し、インデックス変数の上
限値が分かるとき 例えばＪａｖａ言語で配列アクセスがa[2*i+1]という形
で行われ、ｉの下限値が５であと分かった場合には、こ
のチェックが行われた時点でa[0]からa[13]までもチェ
ック済みであるとしてＣ＿ＧＥＮ［Ｂ］に追加する。ま
た、配列アクセスがa[10-i]という形であり、ｉの上限
値が５であることが分かった場合には、このチェックが
行われた時点でa[0]からa[5]までもチェック済みである
としてＣ＿ＧＥＮ［Ｂ］に加える。

【００９３】配列のベース変数ａの変更の処理は上の
Ａ．及びＢ．の場合と変わりない。配列インデックス変
数ｖの変更処理は上で述べたＡ．及びＢ．の場合とは異
なる。当該配列レンジ・チェックがｖ又はｆ（ｖ）で表
され且つ正又は負の定数による加算又は減算による場合
のみＣ＿ＧＥＮ［Ｂ］に含めておくことができる。すな
わち、正又は負の定数による加算でない場合には、変更
される配列インデックス変数ｖに関連するＣ＿ＧＥＮ
［Ｂ］の要素はＣ＿ＧＥＮ［Ｂ］から除去される。一
方、正又は負の定数による加算の場合には、その変更と
は反対に当該定数による減算がＣ＿ＧＥＮ［Ｂ］内の関
係する配列レンジ・チェックに対して実施される。すな
わち、変更がｖ＋ｃの場合には、配列レンジ・チェック
Ｃのｖ又はｆ（ｖ）がｖ−ｃ又はｆ（ｖ−ｃ）に置換さ
れる。

【００９４】このように反対の変更を実施しなければな
らないのは、命令をたどる方向が異なるからである。上
で述べたＡ．及びＢ．の場合には実行とは逆順であった
ので、例えばｉ＋＋という変更がＣ＿ＧＥＮ［Ｂ］に収
集されたｉ≦ｕｂ（ａ）より上（前）に存在している場
合には、このｉ≦ｕｂ（ａ）のｉはそのベーシック・ブ
ロックの先頭から見るとｉ＋１になる。一方、ここでは
実行順に命令をたどるので、例えばｉ＋＋という変更が
Ｃ＿ＧＥＮ［Ｂ］に収集されたｉ≦ｕｂ（ａ）より下
（後）に存在している場合には、このｉ≦ｕｂ（ａ）の
ｉをそのベーシック・ブロックの後端から見るとｉ−１
になる。よってこのような取扱いの差が生じるのであ
る。

【００９５】次にステップ３２０を説明する。ここでは
上で収集したＣ＿ＧＥＮ［Ｂ］を用いて次の式によるデ
ータ・フロー解析（data-flow analysis）を行う。 全てのＰ∈Pred(B)について、Ｂが初期ブロックでない
場合、 C_IN[B] = ∩ C_OUT[P] Ｂが初期ブロックである場合、 C_IN[B] = φ C_OUT[B] = C_GEN[B] ∪ forward(C_IN[B], B) なお、Pred(B)は、Ｂの直前にくるベーシック・ブロッ
クＰを示すものである。また、forward(C_IN[B], B)は
以下に詳述する。上の式でＣ＿ＩＮ［Ｂ］は、そのベー
シック・ブロックＢの直前のベーシック・ブロックＰの
Ｃ＿ＯＵＴ［Ｐ］の積集合となることを示している。但
し、Ｂがプログラムの先頭のベーシック・ブロックであ
る場合には、Ｃ＿ＩＮ［Ｂ］は空である。そして、この
Ｃ＿ＩＮ［Ｂ］をもちいて、Ｃ＿ＯＵＴ［Ｂ］が求めら
れる。すなわち、Ｃ＿ＯＵＴ［Ｂ］＝Ｃ＿ＧＥＮ［Ｂ］
∪ forward((C_IN[B], B)である。これを図８にまとめ
ておく。

【００９６】Ａ．の処理と組み合わせてＣ．の実施する
場合には、次の式によるデータ・ブロー解析を行う。な
お、ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］はＡ．の処理で作成し
たものを使用する。 全てのＰ∈Pred(B)について、Ｂが初期ブロックでない
場合、 C_IN[B] = （∩ C_OUT[P]）∪VERSION_OR[B] Ｂが初期ブロックである場合、 C_IN[B] = VERSION_OR[B] C_OUT[B] = C_GEN[B] ∪ forward(C_IN[B], B)

【００９７】ではforward(C_IN[B], B)を擬似コードで
表１７に示す。

【表１７】 forward(C_IN[B], B){ T = 0; for each check C ∈ C_IN[B] do case C of lb <= v: case AFFECT(B, v) of unchanged: T = T ∪ { lb <= v } increment: if 加算する値 c が定数 then T = T ∪ { lb <= v - c } else T = T ∪ { lb <= v } decrement: if 減算する値 c が定数 then T = T ∪ { lb <= v + c } /* そうでなければTに入れない */ multiply: T = T ∪ { lb <= v } div > 1: /* Tに入れない */ div < 1: T = T ∪ { lb <= v } changed: /* Tに入れない */ end case v <= ub: case AFFECT(B, v) of unchanged: T = T ∪ { v <= ub } increment: if 加算する値 c が定数 then T = T ∪ { v - c <= ub } /* そうでなければTに入れない */ decrement: if 減算する値 c が定数 then T = T ∪ { v + c <= ub } else T = T ∪ { v <= ub } multiply: /* Tには入れない */ div > 1: T = T ∪ { v <= ub } div < 1: /* Tには入れない */ changed: /* Tには入れない */ end case lb <= f(v): case AFFECT(B, v) of unchanged: T = T ∪ { lb <= f(v) } increment: if f(v)が単調な関数 and 加算する値 c が定数 then T = T ∪ { lb <= f( v - c ) } else if vが増加するとf(v)も増加 then T = T ∪ { lb <= f(v) } decrement: if f(v)が単調な関数 and 減算する値 c が定数 then T = T ∪ { lb <= f( v + c ) } else if vが減少するとf(v)が増加 then T = T ∪ { lb <= f(v) } /* そうでなければTに入れない */ multiply, div < 1: if vが増加するとf(v)も増加 then T = T ∪ { lb <= f(v) } div > 1: if vが減少するとf(v)は増加 then T = T ∪ { lb <= f(v) } changed: /* Tに入れない */ end case f(v) <= ub: case AFFECT(B, v) of unchanged: T = T ∪ { f(v) <= ub } increment: if f(v)が単調な関数 and 加算する値 c が定数 then T = T ∪ { f( v - c ) <= ub } else if vが増加するとf(v)は減少 then T = T ∪ { f(v) <= ub } decrement: if f(v)が単調な関数 and 減算する値 c が定数 then T = T ∪ { f( v + c ) <= ub }
else if vが減少するとf(v)も減少 then T = T ∪ { f(v) <= ub } /* そうでなければTに入れない */ multiply, div < 1: if vが増加するとf(v)は減少 then T = T ∪ { f(v) <= ub } div > 1: if vが減少するとf(v)も減少 then T = T ∪ { f(v) <= ub } changed: /* Tに入れない */ end case end case } return(T) }

【００９８】forward(C_IN[B], B)の最終的な出力はＴ
である。forward(C_IN[B], B)はＣ＿ＩＮ［Ｂ］に含ま
れる配列レンジ・チェックの形式により大きく４つの部
分に分けられる。すなわち、配列インデックス変数ｖに
ついて、ｌｂ≦ｖ（配列の下限）の形式の場合、ｖ≦ｕ
ｂ（配列の上限）の場合、ｌｂ≦ｆ（ｖ）の場合、ｆ
（ｖ）≦ｕｂの場合である。そして、それぞれの場合の
中で、配列インデックス変数ｖに対する操作（AFFECT
(B, v))によってさらに場合分けされる。以下それぞれ
の場合について説明する。

【００９９】（１）ｌｂ≦ｖの場合 配列インデックス変数ｖに何等の操作も実施しない場合
（unchanged）には、ｌｂ≦ｖをそのままＴに入れる。
配列インデックス変数ｖを増加させる操作を実施する場
合（increment）、加算する値ｃが定数であるならばｌ
ｂ≦ｖ−ｃをＴに入れる。もしｃが定数でない場合には
ｌｂ≦ｖをＴに入れる。配列インデックス変数ｖを減少
させる操作を実施する場合（decrement）、減算する値
ｃが定数であるならばｌｂ≦ｖ＋ｃをＴに入れる。ｃが
定数でなければ、その配列レンジ・チェックをＴには入
れない。配列インデックス変数ｖを掛け算する場合（mu
ltiply）には、ｌｂ≦ｖをＴに入れる。配列インデック
ス変数ｖを１より大きい値で割り算する場合（div>1）
には、その配列レンジ・チェックをＴに入れない。配列
インデックス変数ｖを１より小さな値で割り算する場合
（div<1）には、ｌｂ≦ｖをＴに入れる。以上述べた操
作以外の操作を配列インデックス変数ｖに行う場合（ch
anged）には、その配列レンジ・チェックをＴには入れ
ない。

【０１００】（２）ｖ≦ｕｂの場合 配列インデックス変数ｖに何等の操作も実施しない場合
（unchanged）には、ｖ≦ｕｂをＴに入れる。配列イン
デックス変数ｖを増加させる操作を実施する場合（incr
ement）には、加算する値ｃが定数であるならばｖ−ｃ
≦ｕｂをＴに入れる。ｃが定数でない場合にはその配列
レンジ・チェックをＴには入れない。配列インデックス
変数ｖを減少させる操作を実施する場合（decrement）
には、減算する値ｃが定数であるならばｖ＋ｃ≦ｕｂを
Ｔに入れる。ｃが定数でない場合にはｖ≦ｕｂをＴに入
れる。配列インデックス変数ｖを掛け算する場合（mult
iply）には、その配列レンジ・チェックをＴには入れな
い。配列インデックス変数ｖを１より大きな値で割り算
する場合（div>1）には、ｖ≦ｕｂをＴに入れる。配列
インデックス変数ｖを１より小さな値で割り算する場合
（div<1）には、その配列レンジ・チェックをＴには入
れない。以上述べた操作以外の操作を配列インデックス
変数ｖに行う場合（changed）には、その配列レンジ・
チェックをＴには入れない。

【０１０１】（３）ｌｂ≦ｆ（ｖ）の場合 配列インデックス変数ｖに何等の操作も実施しない場合
（unchanged）には、ｌｂ≦ｆ（ｖ）をそのままＴに入
れる。配列インデックス変数ｖを増加させる操作を実施
する場合（increment）には、ｆ（ｖ）が単調な関数で
あり且つ加算する値ｃが定数であれば、ｌｂ≦ｆ（ｖ−
ｃ）をＴに入れる。この条件が当てはまらない場合であ
ってｖが増加するとｆ（ｖ）も増加するならば、ｌｂ≦
ｆ（ｖ）をＴに入れる。配列インデックス変数ｖを減少
させる操作を実施する場合（decrement）には、ｆ
（ｖ）が単調な関数であって減算する値ｃが定数なら
ば、ｌｂ≦ｆ（ｖ＋ｃ）をＴに入れる。上の条件が満た
されない場合であってｖが減少するとｆ（ｖ）が増加す
る場合には、ｌｂ≦ｆ（ｖ）をＴに入れる。そうでない
場合には、その配列レンジ・チェックをＴには入れな
い。配列インデックス変数ｖを掛け算する場合（multip
ly）及び１より小さな値で割り算する場合（div<1）、
ｖが増加するとｆ（ｖ）も増加するならば、ｌｂ≦ｆ
（ｖ）をＴに入れる。配列インデックス変数ｖを１より
大きな値で割り算する場合（div>1）には、ｖが減少す
るとｆ（ｖ）が増加するならば、ｌｂ≦ｆ（ｖ）をＴに
入れる。以上の操作以外の操作を配列インデックス変数
ｖに施す場合（changed）には、その配列レンジ・チェ
ックをＴには入れない。

【０１０２】（４）ｆ（ｖ）≦ｕｂの場合 配列インデックス変数ｖに何等の操作も施さない場合
（unchanged）には、ｆ（ｖ）≦ｕｂをそのままＴに入
れる。配列インデックス変数ｖを増加させる操作を実施
する場合（increment）には、ｆ（ｖ）が単調な関数で
あって加算する値ｃが定数ならば、ｆ（ｖ−ｃ）≦ｕｂ
をＴに入れる。上の条件が満たされない場合には、ｖが
増加するとｆ（ｖ）が減少するならば、ｆ（ｖ）≦ｕｂ
をＴに入れる。配列インデックス変数ｖを減少させる操
作を実施する場合（decrement）には、ｆ（ｖ）が単調
な関数であって減算する値ｃが定数ならば、ｆ（ｖ＋
ｃ）≦ｕｂをＴに入れる。上の条件が満たされない場合
には、ｖが減少するとｆ（ｖ）も減少するならば、ｆ
（ｖ）≦ｕｂをＴに入れる。そうでなければ、その配列
レンジ・チェックをＴには入れない。配列インデックス
ｖに掛け算を実施する場合（multiply）及び１より小さ
な値で割り算する場合（div<1）、ｖが増加するとｆ
（ｖ）が減少するならば、ｆ（ｖ）≦ｕｂをＴに入れ
る。配列インデックス変数ｖを１より大きな値で割り算
する場合には、ｖが減少するとｆ（ｖ）も減少するなら
ば、ｆ（ｖ）≦ｕｂをＴに入れる。以上の操作以外の操
作を実施する場合（changed）には、その配列レンジ・
チェックをＴには入れない。

【０１０３】ステップ３３０の処理はＣ＿ＩＮ［Ｂ］を
基に次のようなアルゴリズムで行う。

【表１８】 for (各ベーシック・ブロックについて実行順に命令を取り出す){ switch(命令){ 配列アクセス命令: その配列レンジ・チェックＣに対して if (ＣがC_IN[B]からチェック済と判断できる){ 配列レンジ・チェックＣを除去 } else { C_IN[B] += Ｃ; } break; 配列のベース変数 a の変更: for (全てのＣ∈ C_IN[B]){ if (Ｃの中に変更された配列ベース a による lb(a)またはub(a)が含まれる){ C_IN[B] -= Ｃ; } } break; インデックス v の変更: for (全てのＣ∈ C_IN[B]){ if (Ｃは変更されたインデックス v 又は v の式 f(v) で構成される){ if (インデックス v が i = i + c (cは正又は負の定数)で変更される){ v を v - c、又はf(v)をf(v - c)として置き換える。 } else { C_IN[B] -= Ｃ; } } } break; } }

【０１０４】表１８が表１６と異なる部分は、取り出し
た配列アクセス命令の場合の処理である。ここでは、当
該配列アクセスの配列レンジ・チェックＣがＣ＿ＩＮ
［Ｂ］からチェック済みであると判断できる場合には、
当該配列レンジ・チェックＣを除去対象として選択す
る。そうでなければ配列レンジ・チェックが必要である
からその配列レンジ・チェックは残す。但し、残した場
合には後の配列レンジ・チェックを除去するのに用いる
ことができるので当該配列レンジ・チェックＣをＣ＿Ｉ
Ｎ［Ｂ］に入れる。ところで、Ｃ＿ＩＮ［Ｂ］からチェ
ック済であると判断できる場合とは、Ｃ＿ＩＮ［Ｂ］の
配列レンジ・チェックに直接包含される場合される場合
に限定されない。以下の場合も、除去対象として選択す
ることができる。

【０１０５】（１）配列インデックスが (I₁ + I₂ +
... + I_n) / N の時にインデックス変数I₁ から I_nま
で全て配列ベースに対してチェック済みであり、Ｎがｎ
に等しい時、この式も配列レンジ・チェック済みの部分
にカバーされているとして扱うことができる。また、配
列の下限が０の言語に限ってはＮがｎ以上の値ならばチ
ェック済として扱える。 （２）Ｊａｖａ言語においては、配列のインデックス
が、Ａ（任意の式） modＮ（Ｎは定数）というように剰
余の形になっている時、Ａが必ず正の値をとれば結果は
０からabs(Ｎ)−１（absは絶対値）の範囲に収まる。こ
れを利用してＡが必ず正の値をとる時、abs(N)−１の定
数値が配列ベースに対してチェック済であればこの配列
アクセスもチェック済として扱える。もし、配列インデ
ックスの下限が０でないプログラミング言語の場合に
は、定数０がチェック済みであるかどうかということも
検査しなければならない。

【０１０６】以上の処理を表１５に適用した場合の例を
示す。まず、ステップ３１０を表１５に適用した場合
に、Ｃ＿ＧＥＮ［Ｂ］は以下のようになる。すなわち、
BB1については、配列アクセスがないのでＣ＿ＧＥＮ［B
B1］は空である。また、BB2には２つの配列レンジ・チ
ェックが存在しており、ｌｂ（ａ）≦ｉ−２，ｉ＋１≦
ｕｂ（ａ）はそのままＣ＿ＧＥＮ［BB2］に入れられる
（（１）配列ベース（２）配列インデックスのうちイン
デックス変数を含む項（３）配列インデックスの最大定
数オフセット及び（４）配列インデックスの最小定数オ
フセットのように記憶装置に記憶する場合には、（１）
ａ（２）ｉ（３）＋１（４）−２となる。）。さらに、
これらの拡張として、ｉ＋１−（ｉ−２）＝３であるか
らｌｂ（ａ）＋３≦ｕｂ（ａ）もチェック済であるとし
て扱える。よってこの情報もＣ＿ＧＥＮ［BB2］に入れ
られる（Ｊａｖａ言語の場合であって、先に示した記憶
方法では（１）ａ（２）null（３）３（４）０）。BB3
には４つの配列レンジ・チェックが存在しており、ｌｂ
（ａ）≦ｉ−２，ｉ＋１≦ｕｂ（ａ），ｌｂ（ａ）≦
５，及び５≦ｕｂ（ａ）はそのままＣ＿ＧＥＮ［BB3］
に入れられる（先に示した記憶方法では、（１）ａ
（２）ｉ（３）＋１（４）−２、（１）ａ（２）null
（３）５（４）５）。ここでは、ｌｂ（ａ）＋３≦ｕｂ
（ａ）をＣ＿ＧＥＮ［BB3］に入れてもよいが、ｌｂ
（ａ）が０のようなＪａｖａ言語等では５≦ｕｂ（ａ）
に包含されるので、ここでは入れない。BB4について
は、配列レンジ・チェックが２つ存在している。ｌｂ
（ａ）≦ｉ−３及びｉ≦ｕｂ（ａ）はそのままＣ＿ＧＥ
Ｎ［BB4］に入れられる（先に示した記憶方法の場合、
（１）ａ（２）ｉ（３）０（４）−３）。またｌｂ
（ａ）＋３≦ｕｂ（ａ）もこれらから導き出されるので
Ｃ＿ＧＥＮ［BB4］に入れる（Ｊａｖａ言語の場合であ
って、先に示した記憶方法では（１）ａ（２）null
（３）３（４）０）。BB5は配列アクセスがないのでＣ
＿ＧＥＮ［BB5］は空である。以下にＣ＿ＧＥＮ［Ｂ］
の結果をまとめておく。

【０１０７】次にステップ３２０の結果を考える。BB1
は初期ブロックであるのでＣ＿ＩＮ［BB1］は空であ
る。またBB1ではＣ＿ＧＥＮ［BB1］も空であるからＣ＿
ＯＵＴ［BB1］も空である。Ｃ＿ＩＮ［BB2］はＣ＿ＯＵ
Ｔ［BB1］が空であるから同じく空である。Ｃ＿ＧＥＮ
［BB2］が存在するのでＣ＿ＧＥＮ［BB2］がそのままＣ
＿ＯＵＴ［BB2］となる。すなわち、ｌｂ（ａ）≦ｉ−
２，ｉ＋１≦ｕｂ（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）
である（先に示した記憶方法では、（１）ａ（２）ｉ
（３）＋１（４）−２、Ｊａｖａ言語である場合には
（１）ａ（２）null（３）３（４）０）。Ｃ＿ＩＮ［BB
3］は、Ｃ＿ＯＵＴ［BB2］と同じになる。Ｃ＿ＯＵＴ
［BB3］は、Ｃ＿ＧＥＮ［BB3］とforward(C_IN[BB3], B
B3)との和集合である。Ｔ=forward(C_IN[BB3], BB3）
は、BB3がｉ＋＋を含むので、Ｃ＿ＩＮ［BB3］のｌｂ
（ａ）≦ｉ−２，ｉ＋１≦ｕｂ（ａ），ｌｂ（ａ）＋３
≦ｕｂ（ａ）は、ｌｂ（ａ）≦ｉ−３，ｉ≦ｕｂ
（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）に修正される（先
に示した記憶方法では、（１）ａ（２）ｉ（３）０
（４）−３、Ｊａｖａ言語である場合には（１）ａ
（２）null（３）３（４）０）。よって、Ｃ＿ＧＥＮ
［BB3］のｌｂ（ａ）≦ｉ−２，ｉ＋１≦ｕｂ（ａ），
ｌｂ（ａ）≦５，及び５≦ｕｂ（ａ）との和集合は、ｌ
ｂ（ａ）≦ｉ−３，ｉ＋１≦ｕｂ（ａ），ｌｂ（ａ）≦
５，及び５≦ｕｂ（ａ）及びｌｂ（ａ）＋３≦ｕｂ
（ａ）である（先に示した記憶方法では、（１）ａ
（２）ｉ（３）＋１（４）−３、（１）ａ（２）null
（３）５（４）５、Ｊａｖａ言語である場合には（１）
ａ（２）null（３）３（４）０）。

【０１０８】Ｃ＿ＩＮ［BB4］はＣ＿ＯＵＴ［BB2］及び
Ｃ＿ＯＵＴ［BB3］の積集合となる。よって、ｌｂ
（ａ）≦ｉ−２，ｉ＋１≦ｕｂ（ａ），ｌｂ（ａ）＋３
≦ｕｂ（ａ）となる（先に示した記憶方法では、（１）
ａ（２）ｉ（３）＋１（４）−２、Ｊａｖａ言語である
場合には（１）ａ（２）null（３）３（４）０）。Ｃ＿
ＯＵＴ［BB4］はＣ＿ＧＥＮ［BB4］とforward(C_IN[BB
4], BB4）の和集合である。forward(C_IN[BB4], BB4）
は、BB4にｉ＋＋が含まれているので、ｌｂ（ａ）≦ｉ
−３，ｉ≦ｕｂ（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）と
なる（先に示した記憶方法では、（１）ａ（２）ｉ
（３）０（４）−３、Ｊａｖａ言語である場合には
（１）ａ（２）null（３）３（４）０）。よって、Ｃ＿
ＧＥＮ［BB4］であるｌｂ（ａ）≦ｉ−３，ｉ≦ｕｂ
（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）との和集合Ｃ＿Ｏ
ＵＴ［BB4］は、ｌｂ（ａ）≦ｉ−３，ｉ≦ｕｂ
（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）となる（先に示し
た記憶方法では、（１）ａ（２）ｉ（３）０（４）−
３、Ｊａｖａ言語である場合には（１）ａ（２）null
（３）３（４）０）。Ｃ＿ＩＮ［BB5］は、Ｃ＿ＯＵＴ
［BB4］と同じである。また、Ｃ＿ＯＵＴ［BB5］も、Ｃ
＿ＧＥＮ［BB5］が空であり且つBB5には配列インデック
スの操作が存在してないので、Ｃ＿ＩＮ［BB5］と同じ
である。以下、結果をまとめておく。

【０１０９】なお、配列ａの下限ｌｂ（ａ）が０である
言語の場合には、以下のような結果が得られる。

【０１１０】ステップ３３０の処理を実施すると以下の
ようになる。BB1には配列アクセスはないので処理は行
われない。BB2にはまずｉ＋＋が存在しているのがＣ＿
ＩＮ［BB2］は空であるから内容の修正は行われず、且
つ２つの配列レンジ・チェックは除去されずに残る。こ
こで２つの配列レンジ・チェックはＣ＿ＩＮ［BB2］に
追加されるが、このBB2にはもう配列アクセスは存在し
ないのでBB2についての処理は終了する。次にBB3に処理
は移行する。Ｃ＿ＩＮ［BB3］はｌｂ（ａ）≦ｉ−２，
ｉ＋１≦ｕｂ（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）で、
まずｉ＋＋が存在するのでこれを修正する。Ｃ＿ＩＮ
［BB3］はｌｂ（ａ）≦ｉ−３，ｉ≦ｕｂ（ａ），ｌｂ
（ａ）＋３≦ｕｂ（ａ）となる(先に示した記憶方法で
は、（１）ａ（２）ｉ（３）０（４）−３、Ｊａｖａ言
語である場合には（１）ａ（２）null（３）３（４）
０）。次に、４つの配列レンジ・チェック（ｌｂ（ａ）
≦ｉ−２，ｉ＋１≦ｕｂ（ａ），ｌｂ≦５及び５≦ｕｂ
（ａ））が存在するので、Ｃ＿ＩＮ［BB3］から除去で
きるものは、ｌｂ（ａ）≦ｉ−２である。残った配列レ
ンジ・チェックはＣ＿ＩＮ［BB3］に入れられるがその
後の処理はない。次にBB4に処理は移行する。Ｃ＿ＩＮ
［BB4］はｌｂ（ａ）≦ｉ−３，ｉ≦ｕｂ（ａ），ｌｂ
（ａ）＋３≦ｕｂ（ａ）である。BB4にはまずｉ＋＋が
あるので、ｌｂ（ａ）≦ｉ−２，ｉ＋１≦ｕｂ（ａ），
ｌｂ（ａ）＋３≦ｕｂ（ａ）をｌｂ（ａ）≦ｉ−３，ｉ
≦ｕｂ（ａ），ｌｂ（ａ）＋３≦ｕｂ（ａ）に修正する
（先に示した記憶方法では、（１）ａ（２）ｉ（３）０
（４）−３、Ｊａｖａ言語である場合には（１）ａ
（２）null（３）３（４）０）。そして、BB4に存在す
る２つの配列レンジ・チェック（ｌｂ（ａ）≦ｉ−３，
ｉ≦ｕｂ（ａ））は共に修正されたＣ＿ＩＮ［BB4］に
カバーされる。よって、BB4では配列レンジ・チェック
は全て除去されることになる。BB5には配列レンジ・チ
ェックは存在しないので、処理は終了する。以上の結果
を表１９に示す。なお、表１９では擬似コードを示す
が、実際には実行可能なコードが生成される。

【表１９】 i = 1; t = 0; do { i++; check(lb(a) <= i-2); check(i+1 <= ub(a)); t += a[i] + a[i-1] + a[i-2]; if (t < 0) { i++; check(i+1 <= ub(a)); check(lb(a) <= 5); /* lb(a)が５以下の言語はこのチェックは必要ない */ check(5 <= ub(a)); t += a[i] + a[i-1] + a[i-2] + a[5]; } i++; t += a[i] + a[i-1] + a[i-2] + a[i-3]; } while(i < n);

【０１１１】以上述べたＡ，Ｂ，Ｃ．の処理は、単独で
も組み合わせても又は従来技術と組み合わせて実行する
ことも可能である。

【０１１２】さらに、このような処理を実行する回路を
作成し、ハードウエアにて実行させることも可能であ
る。

【０１１３】

【効果】データ・フロー解析を使用して配列レンジ・チ
ェック情報を収集し、バージョニングやチェックの前倒
しを行い、不要な配列レンジ・チェックを除去するもの
ことができた。

【０１１４】例外の発生を利用してプログラムを書くこ
とができる言語にも対応させ、より多くの配列レンジチ
ェックを除去できるようにすることもできた。

【０１１５】さらに、データ・フロー解析を行って配列
レンジ・チェック情報を収集し、配列レンジ・チェック
の最適化を行うこともできた。

【０１１６】また、ループのバージョニングも行うこと
ができた。

【図面の簡単な説明】

【図１】本発明のシステム全体の概要図である。

【図２】Ａ．ループに対するバージョニングにより不要
な配列レンジ・チェックを除去する部分のメイン・フロ
ーを表した図である。

【図３】図２のステップ１２０の処理フローを表した図
である。

【図４】表１０の例のフローグラフである。

【図５】Ｂ．データ・フロー解析を実行順序とは逆順に
行って配列レンジ・チェックを最適化する部分のメイン
・フローを表した図である。

【図６】図５のステップ２２０の処理フローを表した図
である。

【図７】Ｃ．データ・フロー解析を実行順に行って配列
レンジ・チェック済の情報を取得し、この情報から不要
な配列レンジ・チェックを除去する部分のメイン・フロ
ーを表した図である。

【図８】図７のステップ３２０の処理フローを表した図
である。

【符号の説明】

１００−３４０ 処理ステップ

フロントページの続き (72)発明者 安江 俊明 神奈川県大和市下鶴間1623番地14 日本 アイ・ビー・エム株式会社 東京基礎研 究所内 (72)発明者 小松 秀昭 神奈川県大和市下鶴間1623番地14 日本 アイ・ビー・エム株式会社 東京基礎研 究所内 (56)参考文献 特開 平１−205231（ＪＰ，Ａ) 特開 昭63−98031（ＪＰ，Ａ) Ａｓｕｒｕ．Ｊ．Ｍ．，Ｏｐｔｉｍｉ ｚａｔｉｏｎ ｏｆ ａｒｒａｙ ｓｕ ｂｓｃｉｐｔ ｒａｎｇｅ ｃｈｅｃｋ ｓ，ＡＣＭ Ｌｅｔｔｅｒｓ ｏｎ Ｐ ｒｏｇｒａｍｍｉｎｇ Ｌａｎｇｕａｇ ｅｓ ａｎｄ Ｓｙｓｔｅｍｓ，1992, Ｖｏｌ．１，Ｎｏ．２，ｐ．109−118 Ｃｈｉｎ，Ｗ−Ｎ他，Ａ ｒｅｅｘａ ｍｉｎａｔｉｏｎ ｏｆ Ｏｐｔｉｍｉ ｚａｔｉｏｎ ｏｆ ａｒｒａｙ ｓｕ ｂｓｃｒｉｐｔ ｒａｎｇｅ ｃｈｅｃ ｋｓ，ＡＣＭ Ｔｒａｎｓａｃｔｉｏｎ ｓ ｏｎ Ｐｒｏｇｒａｍｍｉｎｇ Ｌ ａｎｇｕａｇｅｓ ａｎｄ Ｓｙｓｔｅ ｍｓ，1995，Ｖｏｌ．17，Ｎｏ．２, ｐ．217−227 Ａｄｌ−Ｔａｂａｔａｂａｉ，Ａ−Ｒ 他，Ｆａｓｔ，Ｅｆｆｅｃｔｉｖｅ Ｃ ｏｄｅ Ｇｅｎｅｒａｔｉｏｎ ｉｎ ａ Ｊｕｓｔ−Ｉｎ−Ｔｉｍｅ Ｊａｖ ａ Ｃｏｍｐｉｌｅｒ，ＡＣＭ ＳＩＧ ＰＬＡＮ Ｎｏｔｉｃｅｓ，1998，Ｖｏ ｌ．33，Ｎｏ．５，ｐ．280−290 Ｋｏｌｔｅ，Ｐ他，Ｅｌｉｍｉｎａｔ ｉｏｎ ｏｆ Ｒｅｄｕｎｄａｎｔ Ａ ｒｒａｙ Ｓｕｂｓｃｒｉｐｔ Ｒａｎ ｇｅ ｃｈｅｃｋｓ，Ｐｒｏｃｅｅｄｉ ｎｇｓ ｏｆ ｔｈｅ ＡＣＭ ＳＩＧ ＰＬＡＮ’95 Ｃｏｎｆｅｒｅｎｃｅ ｏｎ Ｐｒｏｇｒａｍｍｉｎｇ Ｌａｎ ｇｕａｇｅ Ｄｅｓｉｇｎ ａｎｄ Ｉ ｍｐｌｅｍｅｎｔａｔｉｏｎ，ｐ．270 −278 (58)調査した分野(Int.Cl.⁷，ＤＢ名) G06F 9/44,9/45 (54)【発明の名称】 ループに対するバージョニングを実行する方法及び装置、配列レンジ・チェックに関する情報を ベーシック・ブロック内において収集する方法及び装置、配列レンジ・チェックに関する情報を 変更する方法、配列レンジ・チェック最適化方法、配列レンジ・チェックのためのコードを生成 する方法、不要配列レンジ・チェック除去方法及び装置、配列レンジ・チェックを選択する方 法、配列レンジ・チェック変更方法、配列レンジ・チェック収集方法、及び配列レンジ・チェッ ク取扱判断方法

Claims (34)

(57)【特許請求の範囲】
1. 【請求項１】プログラム内の配列アクセスに対する配列
   レンジ・チェックの情報を用いて、ループに対しバージ
   ョニングを実行する方法であって、実行とは逆順に、各ベーシックブロックの先頭でバージ
   ョニングの対象となる各ベーシックブロック内の 配列レ
   ンジ・チェックの集合である第１要処理配列レンジ・チ
   ェック情報を収集し且つ記憶装置に記憶する収集ステッ
   プと、 深さ優先探索のポストオーダー・トラバーサルの順番
   で、前記第１要処理配列レンジ・チェック情報を第２の
   条件に従って伝搬させ、各ベーシック・ブロックの先頭
   でバージョニングの対象となる配列レンジ・チェックの
   集合である第２要処理配列レンジ・チェック情報を生成
   し且つ記憶装置に記憶する第２要処理配列レンジ・チェ
   ック情報生成ステップと、 前記第２要処理配列レンジ・チェック情報を用いて、ル
   ープの前に前記バージョニングのためのチェック・コー
   ド、及び各実行状態における実行コードを生成し、記憶
   装置に記憶するステップと、 を含むループに対するバージョニングを実行する方法。
2. 【請求項２】前記第１要処理配列レンジ・チェック情報
   の収集ステップは、ベーシック・ブロック内において、 配列アクセスのインデックス変数が変更されない場合に
   は当該配列アクセスに対する配列レンジ・チェックの情
   報をそのまま収集し、 配列レンジ・チェックにおけるインデックス変数が正又
   は負の定数の加算により変更されている場合には当該イ
   ンデックス変数に前記定数を加算することにより生ずる
   変更を反映させた後の配列レンジ・チェックの情報を収
   集する、 請求項１記載のループに対するバージョニングを実行す
   る方法。
3. 【請求項３】前記第２要処理配列レンジ・チェック情報
   の生成ステップは、 あるベーシック・ブロックの前記第１要処理配列レンジ
   ・チェック情報と、当該あるベーシック・ブロックの後
   端でバージョニングの対象となる配列レンジ・チェック
   の集合である第３要処理配列レンジ・チェック情報をベ
   ーシックブロック内のインデックス変数の変更に応じて
   変更した第４要処理配列レンジ・チェック情報との和集
   合を計算する、 請求項１記載のループに対するバージョニングを実行す
   る方法。
4. 【請求項４】前記第４要処理配列レンジ・チェック情報
   は、 前記あるベーシック・ブロックにおいて、前記第３要処
   理配列レンジ・チェック情報に含まれる配列レンジ・チ
   ェックにおけるインデックス変数が正又は負の定数の加
   算により変更される場合、当該インデックス変数に前記
   定数を加算することにより生ずる変更を前記第３要処理
   配列レンジ・チェック情報に含まれる配列レンジ・チェ
   ックに反映させることにより生成される、 請求項３記載のループに対するバージョニングを実行す
   る方法。
5. 【請求項５】前記第３要処理配列レンジ・チェック情報
   は、 前記あるベーシック・ブロックの直後のベーシック・ブ
   ロックであって前記あるベーシック・ブロックと同じル
   ープに含まれる全てのベーシック・ブロックの第２要処
   理配列レンジ・チェック情報を用いて生成される、 請求項４記載のループに対するバージョニングを実行す
   る方法。
6. 【請求項６】プログラム内の配列アクセスに対する配列
   レンジ・チェックに関する情報を、ベーシック・ブロッ
   ク内において収集する方法であって、 前記ベーシック・ブロック内の命令を、実行とは逆順
   で、検査するステップと、 当該検査において前記命令が配列アクセスを含む場合、
   当該配列アクセスに対して必要となる配列レンジ・チェ
   ックの情報を記憶装置に記憶するステップと、 前記検査において前記命令が、記憶された配列レンジ・
   チェックに関連する配列インデックス変数の変更を含む
   場合には、当該変更が配列インデックス変数の正又は負
   の定数の加算であるか判断するステップと、 前記変更が前記定数の加算である場合には、前記配列レ
   ンジ・チェックにおける配列インデックス変数に前記定
   数を加算することにより生じる、前記配列レンジ・チェ
   ックの変更を計算するステップと、 計算された前記配列レンジ・チェックの変更を反映した
   後の配列レンジ・チェックを記憶装置に記憶するステッ
   プと、 を含む配列レンジ・チェックに関する情報をベーシック
   ・ブロック内において収集する方法。
7. 【請求項７】前記検査において前記命令が、前記配列レ
   ンジ・チェックにより発生する例外が当該命令より先に
   起こることによって副作用を生じるような命令である場
   合には、当該検査までに記憶された配列レンジ・チェッ
   クを破棄するステップをさらに含む請求項６記載の配列
   レンジ・チェックに関する情報をベーシック・ブロック
   内において収集する方法。
8. 【請求項８】プログラム内の配列アクセスに対する配列
   レンジ・チェックを最適化する方法であって、実行とは逆順に、ベーシックブロックの先頭に移動可能
   な各ベーシックブロック内の 配列レンジ・チェックの集
   合である第１要処理配列レンジ・チェック情報を収集し
   且つ記憶装置に記憶する収集ステップと、 前記プログラムにおけるデータ・フローに従って、ベー
   シック・ブロック中に例外を発生させる配列レンジ・チ
   ェックをそれより前に移動させることによって副作用を
   生じるような副作用命令を含むか否かの情報を用い且つ
   前記第１要処理配列レンジ・チェック情報を伝搬させ、
   各ベーシック・ブロックの後端に移動可能な配列レンジ
   ・チェックの集合である第２要処理配列レンジ・チェッ
   ク情報を生成し且つ記憶装置に記憶する第２要処理配列
   レンジ・チェック情報生成ステップと、 各ベーシック・ブロック内において、前記第２要処理配
   列レンジ・チェック情報をプログラムの意味を変えない
   ように修正しながら実行とは逆順に各命令をたどり、前
   記第２要処理配列レンジ・チェック情報を用いて配列レ
   ンジ・チェックのためのコードを生成し且つ記憶装置に
   記憶するコード生成ステップと、 を含む配列レンジ・チェック最適化方法。
9. 【請求項９】前記第１要処理配列レンジ・チェック情報
   の収集ステップは、ベーシック・ブロック内において、 配列アクセスのインデックス変数が変更されない場合に
   は当該配列アクセスに対する配列レンジ・チェックの情
   報をそのまま収集し、 配列レンジ・チェックにおけるインデックス変数が正又
   は負の定数の加算により変更されている場合には当該イ
   ンデックス変数に前記定数を加算することにより生ずる
   変更を反映させた後の配列レンジ・チェックの情報を収
   集し、 前記ベーシック・ブロックが前記副作用命令を含む場合
   には、当該ベーシック・ブロックにおいて収集した配列
   レンジ・チェックの情報を破棄する、 請求項８記載の配列レンジ・チェック最適化方法。
10. 【請求項１０】前記第２要処理配列レンジ・チェック情
    報の生成ステップは、１）あるベーシック・ブロックの直後にあるすべての後
    続ベーシック・ブロックについて、下記の（１−１）ま
    たは（１−２）を第３要処理配列レンジ・チェック情報
    として生成し、 （１−１）前記後続 ベーシック・ブロックが前記プログ
    ラムの終端である場合又は前記後続ベーシック・ブロッ
    クが前記プログラムの終端でなく且つ前記副作用命令を
    含む場合には、当該後続ベーシック・ブロックの前記第
    １要処理配列レンジ・チェック情報そのもの、 （１−２） 前記後続ベーシック・ブロックが前記プログ
    ラムの終端でなく且つ前記副作用命令を含まない場合に
    は、前記後続ベーシック・ブロックの前記第２要処理配
    列レンジ・チェック情報を当該ベーシックブロック内の
    インデックス変数の変更に応じて変更した第４要処理配
    列レンジ・チェック情報と前記後続ベーシック・ブロッ
    クの前記第１要処理配列レンジ・チェック情報の和集
    合、 ２）すべての前記後続ベーシック・ブロックについて生
    成された前記第３要処理配列レンジ・チェック情報の積
    集合を、 前記あるベーシック・ブロックの第２要処理配
    列レンジ・チェック情報として生成し、 ３）上記１）および２）をすべてのベーシック・ブロッ
    クについて実行する、 請求項８記載の配列レンジ・チェ
    ック最適化方法。
11. 【請求項１１】前記コードの生成ステップは、前記第２要処理配列レンジ・チェック情報の修正処理に
    おいて、 配列レンジ・チェックにおけるインデックス変
    数が正又は負の定数の加算により変更されている場合に
    は、当該インデックス変数に前記定数を加算することに
    より生ずる変更を反映させた後の配列レンジ・チェック
    の情報に修正するとともに、前記ベーシック・ブロック
    が前記副作用命令を含む場合には、当該ベーシック・ブ
    ロックにおいて収集した配列レンジ・チェックの情報を
    破棄し、 配列アクセスに対する配列レンジ・チェックの範囲が、
    前記第２要処理配列レンジ・チェック情報に含まれる配
    列レンジ・チェックの範囲より狭い場合には、当該配列
    アクセスに対して、前記第２要処理配列レンジ・チェッ
    ク情報に含まれる配列レンジ・チェックのためのコード
    を生成するステップを含む、請求項８記載の配列レンジ
    ・チェック最適化方法。
12. 【請求項１２】前記第４要処理配列レンジ・チェック情
    報は、 前記後続ベーシック・ブロックにおいて、前記第２要処
    理配列レンジ・チェック情報に含まれる配列レンジ・チ
    ェックにおけるインデックス変数が正又は負の定数の加
    算により変更される場合、当該インデックス変数に前記
    定数を加算することにより生ずる変更を前記第２要処理
    配列レンジ・チェック情報に含まれる配列レンジ・チェ
    ックに反映させることにより生成される、 請求項１０記載の配列レンジ・チェック最適化方法。
13. 【請求項１３】プログラム内の配列レンジ・チェックを
    最適化する場合に、各ベーシック・ブロックの後端まで
    に伝搬された、配列アクセスに対して必要となる配列レ
    ンジ・チェックの集合である要処理配列レンジ・チェッ
    ク情報を用いて、挿入すべき、配列レンジ・チェックの
    ためのコードを生成する方法であって、 前記ベーシック・ブロック内の命令を、実行とは逆順
    に、検査するステップと、 当該検査において前記命令が配列アクセスを含む場合に
    は、前記要処理配列レンジ・チェック情報内の配列レン
    ジ・チェックの範囲より、当該配列アクセスに必要な配
    列レンジ・チェックの範囲が狭いか判断し、狭いと判断
    された場合には、前記要処理配列レンジ・チェック情報
    内の配列レンジ・チェックに対応するコードを生成する
    ステップと、 前記検査において前記命令が、前記要処理配列レンジ・
    チェック情報に含まれる配列のインデックス変数の変更
    を含む場合には、当該変更が配列インデックス変数の正
    又は負の定数の加算であるか判断し、前記変更が前記定
    数の加算である場合には、前記定数を記憶装置に記憶す
    るとともに、前記配列レンジ・チェックにおけるインデ
    ックス変数に前記定数を加算することにより生じる前記
    配列レンジ・チェックの変更を計算し、当該変更を反映
    した後の配列レンジ・チェックを記憶装置に記憶するス
    テップと、 を含む配列レンジ・チェックのためのコードを生成する
    方法。
14. 【請求項１４】前記検査において前記命令が、例外を発
    生させる配列レンジ・チェックをそれより前に移動させ
    ることによって副作用を生じるような命令であるか判断
    するステップと、 前記判断が真である場合、前記要処理配列レンジ・チェ
    ック情報を破棄するステップとを含む請求項１３記載の
    配列レンジ・チェックのためのコードを生成する方法。
15. 【請求項１５】プログラム内の配列レンジ・チェックの
    うち不要な配列レンジ・チェックを除去する方法であっ
    て、実行の順番で、各ベーシックブロックの終端でチェック
    済みとして取り扱うことができる各ベーシックブロック
    内の 配列レンジ・チェックの集合である第１処理済配列
    レンジ・チェック情報を収集する収集ステップと、 前記プログラムにおけるデータ・フローに従って、前記
    第１処理済配列レンジ・チェック情報を伝搬させ、各ベ
    ーシック・ブロックの先頭でチェック済みとして取り扱
    うことができる配列レンジ・チェックの集合である第２
    処理済配列レンジ・チェック情報を生成する第２処理済
    配列レンジ・チェック情報生成ステップと、 各ベーシック・ブロック内において、前記第２処理済配
    列レンジ・チェック情報をプログラムの意味を変えない
    ように修正しつつ実行の順番に各命令をたどり、前記第
    ２処理済配列レンジ・チェック情報を用いて配列レンジ
    ・チェックを除去するステップとを含む不要配列レンジ
    ・チェック除去方法。
16. 【請求項１６】前記第１処理済配列レンジ・チェック情
    報の収集ステップは、ベーシック・ブロック内におい
    て、 配列アクセスのインデックス変数が変更されない場合に
    は当該配列アクセスに対する配列レンジ・チェックの情
    報をそのまま収集し、 配列レンジ・チェックにおけるインデックス変数が正又
    は負の定数の加算により変更されている場合には当該イ
    ンデックス変数に前記定数を減算することにより生ずる
    変更を反映させた後の配列レンジ・チェックの情報を収
    集する、 請求項１５記載の不要配列レンジ・チェック除去方法。
17. 【請求項１７】前記第１処理済配列レンジ・チェック情
    報の収集ステップは、 配列レンジ・チェックにおける配列インデックスの最小
    定数オフセット及び最大定数オフセット及び配列の下限
    から、定数インデックスについてチェック済みとして扱
    うことができる上限及び下限で規定される範囲を収集す
    るステップをさらに含む、 請求項１５記載の不要配列レンジ・チェック除去方法。
18. 【請求項１８】前記第１処理済配列レンジ・チェック情
    報の収集ステップは、 配列レンジ・チェックにおけるインデックス変数の下限
    値又は上限値及び配列の下限から、定数インデックスに
    ついてチェック済みとして扱うことができる上限及び下
    限で規定される範囲を収集するステップをさらに含む、 請求項１５記載の不要配列レンジ・チェック除去方法。
19. 【請求項１９】前記第２処理済配列レンジ・チェック情
    報の生成ステップは、１）あるベーシック・ブロックの直前にあるすべての先
    行ベーシック・ブロックについて、下記の（１−１）ま
    たは（１−２）を第３処理済配列レンジ・チェック情報
    として生成し、 （１−１） 前記先行 ベーシック・ブロックが前記プロ
    グラムの先頭である場合には、前記先行ベーシック・ブ
    ロックの前記第１処理済配列レンジ・チェック情報その
    もの、 （１−２） 前記先行ベーシック・ブロックが前記プログ
    ラムの先頭でない場合には、前記先行ベーシック・ブロ
    ックの前記第２処理済配列レンジ・チェック情報をペー
    ジブロック内のインデックス変数の変更に応じて変更し
    た第４処理済配列レンジ・チェック情報と前記先行ベー
    シック・ブロックの前記第１処理済配列レンジ・チェッ
    ク情報の和集合、 ２）すべての前記先行ベーシック・ブロックについて生
    成された前記第３処理済配列レンジ・チェック情報の積
    集合を、 前記あるベーシック・ブロックの第２処理済配
    列レンジ・チェック情報として生成し、 ３）上記１）および２）をすべてのベーシック・ブロッ
    クについて実行する、 請求項１５記載の不要配列レンジ
    ・チェック除去方法。
20. 【請求項２０】前記配列レンジの除去ステップは、前記第２要処理済配列レンジ・チェック情報の修正処理
    において、 配列レンジ・チェックにおけるインデックス
    変数が正又は負の定数の加算により変更されている場合
    には当該インデックス変数に前記定数を減算することに
    より生ずる変更を反映させた後の配列レンジ・チェック
    の情報に修正する、 請求項１５記載の不要配列レンジ・チェック除去方法。
21. 【請求項２１】前記第４処理済配列レンジ・チェック情
    報は、 前記先行ベーシック・ブロックにおいて、前記第２処理
    済配列レンジ・チェック情報に含まれる配列レンジ・チ
    ェックにおけるインデックス変数が正又は負の定数の加
    算により変更される場合、当該インデックス変数に前記
    定数を減算することにより生ずる変更を前記第２処理済
    配列レンジ・チェック情報に含まれる配列レンジ・チェ
    ックに反映させることにより生成される、 請求項１９記載の不要配列レンジ・チェック除去方法。
22. 【請求項２２】プログラム内の配列レンジ・チェックの
    うち不要なものを除去する場合に、各ベーシック・ブロ
    ックの先頭に伝搬された、配列アクセスに対する配列レ
    ンジ・チェックの集合である処理済配列レンジ・チェッ
    ク情報を用いて、除去の対象となる配列レンジ・チェッ
    クを選択する方法であって、 前記ベーシック・ブロック内の命令を、実行の順番で、
    検査するステップと、 当該検査において前記命令が配列アクセスを含む場合、
    当該配列アクセスに必要な配列レンジ・チェックの範囲
    が前記処理済配列レンジ・チェック情報に含まれる配列
    レンジ・チェックの範囲でカバーされるのか判断するス
    テップと、 カバーされると判断された場合には、前記配列アクセス
    に必要な配列レンジ・チェックを選択するステップと、 前記検査において前記命令が、前記処理済配列レンジ・
    チェック情報に含まれる配列レンジ・チェックのインデ
    ックス変数の変更を含む場合には、当該変更がインデッ
    クス変数の正又は負の定数の加算であるか判断するステ
    ップと、 前記変更が定数の加算である場合には、前記定数を記憶
    装置に記憶するステップと、 前記変更が前記定数の加算である場合には、前記配列レ
    ンジ・チェックにおけるインデックス変数に前記定数を
    減算することにより生じる、前記配列レンジ・チェック
    の変更を計算するステップと、 計算された前記配列レンジ・チェックの変更を反映した
    後の配列レンジ・チェックを記憶装置に記憶するステッ
    プと、 を含む配列レンジ・チェックを選択する方法。
23. 【請求項２３】前記カバーされるのか判断するステップ
    が、 前記処理済配列レンジ・チェック情報に、同一の配列ベ
    ースを有する配列レンジ・チェックについて、インデッ
    クス変数Ｉ_k（ｋ＝１，．．．ｎ）が含まれているか検
    査するステップと、 定数Ｌがｎ以上という条件に合致するか判断するステッ
    プと、 全てのｋについて前記インデックス変数Ｉ_kが含まれて
    いると判断され且つ定数Ｌとｎの関係が所定の条件に合
    致する場合、（Ｉ₁＋Ｉ₂＋．．．＋Ｉ_n）／Ｌが配列イ
    ンデックスである配列アクセスの配列レンジ・チェック
    を選択するステップと、 を含む請求項２２記載の配列レンジ・チェックを選択す
    る方法。
24. 【請求項２４】前記カバーされるのか判断するステップ
    が、 前記処理済配列レンジ・チェック情報に、定数インデッ
    クスに関する配列レンジ・チェックについて、定数Ｎの
    絶対値に１を減じた定数が含まれているか検査するステ
    ップと、 配列インデックスであるＡ mod ＮのＡが正であるか判
    断するステップと、 前記定数Ｎの絶対値に１を減じた定数が含まれており且
    つ前記処理済配列レンジ・チェック情報に定数０を実質
    的に含み且つ前記Ａが正である場合、前記配列インデッ
    クスＡ mod Ｎを含む配列アクセスの配列レンジ・チェ
    ックを選択するステップと、 を含む請求項２２記載の配列レンジ・チェックを選択す
    る方法。
25. 【請求項２５】プログラム内の配列アクセスが配列のレ
    ンジを越えていないことを検査するための配列レンジ・
    チェックであってチェック済みであるとして取り扱うこ
    とができる配列レンジ・チェックを前記プログラムのベ
    ーシック・ブロック内において収集する方法であって、 配列レンジ・チェックを検出するステップと、 前記検出された配列レンジ・チェックにおける配列イン
    デックスの最小定数オフセット及び最大定数オフセット
    及び配列の下限から、定数インデックスについてチェッ
    ク済みとして扱うことができる上限及び下限を計算し、
    計算された当該上限及び下限で規定される範囲に関する
    配列レンジ・チェックを記憶装置に記憶するステップ
    と、 を含む配列レンジ・チェック収集方法。
26. 【請求項２６】プログラム内の配列アクセスが配列のレ
    ンジを越えていないことを検査するための配列レンジ・
    チェックであってチェック済みであるとして取り扱うこ
    とができる配列レンジ・チェックを前記プログラムのベ
    ーシック・ブロック内において収集する方法であって、 配列レンジ・チェックを検出するステップと、 前記検出された配列レンジ・チェックにおけるインデッ
    クス変数の下限値又は上限値及び配列の下限から、定数
    インデックスについてチェック済みとして扱うことがで
    きる上限及び下限を計算し、計算された当該上限及び下
    限で規定される範囲に関する配列レンジ・チェックを記
    憶装置に記憶するステップと、 を含む配列レンジ・チェック収集方法。
27. 【請求項２７】プログラム内の配列アクセスに対する配
    列レンジ・チェックの情報を用いて、ループに対しバー
    ジョニングを実行する装置であって、実行とは逆順に、各ベーシックブロックの先頭でバージ
    ョニングの対象となる各ベーシックブロック内の 配列レ
    ンジ・チェックの集合である第１要処理配列レンジ・チ
    ェック情報を収集し且つ記憶装置に記憶する収集手段
    と、 深さ優先探索のポストオーダー・トラバーサルの順番
    で、前記第１要処理配列レンジ・チェック情報を伝搬さ
    せ、各ベーシック・ブロックの先頭でバージョニングの
    対象となる配列レンジ・チェックの集合である第２要処
    理配列レンジ・チェック情報を生成し且つ記憶装置に記
    憶する第２要処理配列レンジ・チェック情報生成手段
    と、 前記第２要処理配列レンジ・チェック情報を用いて、ル
    ープの前に前記バージョニングのためのチェック・コー
    ド、及び各実行状態における実行コードを生成し、記憶
    装置に記憶する手段と、 を含むループに対するバージョニングを実行する装置。
28. 【請求項２８】プログラム内の配列アクセスに対する配
    列レンジ・チェックに関する情報を、ベーシック・ブロ
    ック内において収集する装置であって、 前記ベーシック・ブロック内の命令を、実行とは逆順
    で、検査する手段と、 当該検査において前記命令が配列アクセスを含む場合、
    当該配列アクセスに対して必要となる配列レンジ・チェ
    ックの情報を記憶装置に記憶する手段と、 前記検査において前記命令が、記憶された配列レンジ・
    チェックに関連する配列インデックス変数の変更を含む
    場合には、当該変更が配列インデックス変数の正又は負
    の定数の加算であるか判断する手段と、 前記変更が前記定数の加算である場合には、前記配列レ
    ンジ・チェックにおける配列インデックス変数に前記定
    数を加算することにより生じる、前記配列レンジ・チェ
    ックの変更を計算する手段と、 計算された前記配列レンジ・チェックの変更を反映した
    後の配列レンジ・チェックを記憶装置に記憶する手段
    と、 を含む配列レンジ・チェックに関する情報をベーシック
    ・ブロック内において収集する装置。
29. 【請求項２９】プログラム内の配列レンジ・チェックの
    うち不要な配列レンジ・チェックを除去する装置であっ
    て、実行の順番で、各ベーシックブロックの終端でチェック
    済みとして取り扱うことができる各ベーシックブロック
    内の 配列レンジ・チェックの集合である第１処理済配列
    レンジ・チェック情報を収集する収集手段と、 前記プログラムにおけるデータ・フローに従って、前記
    第１処理済配列レンジ・チェック情報を伝搬させ、各ベ
    ーシック・ブロックの先頭でチェック済みとして取り扱
    うことができる配列レンジチェックの集合である第２処
    理済配列レンジ・チェック情報を生成する第２処理済配
    列レンジ・チェック情報生成手段と、 各ベーシック・ブロック内において、前記第２処理済配
    列レンジ・チェック情報をプログラムの意味を変えない
    ように修正しつつ実行の順番に各命令をたどり、前記第
    ２処理済配列レンジ・チェック情報を用いて配列レンジ
    ・チェックを除去する手段と、 を含む不要配列レンジ・チェック除去装置。
30. 【請求項３０】プログラム内の配列アクセスに対する配
    列レンジ・チェックの情報を用いて、ループに対しバー
    ジョニングを実行するバージョニング・プログラムを格
    納した記憶媒体であって、 前記バージョニング・プログラムは、コンピュータに、実行とは逆順に、各ベーシックブロックの先頭でバージ
    ョニングの対象となる各ベーシックブロック内の 配列レ
    ンジ・チェックの集合である第１要処理配列レンジ・チ
    ェック情報を収集し且つ記憶装置に記憶する収集ステッ
    プであって、各ベーシック・ブロック内において、配列
    アクセスのインデックス変数が変更されない場合には当
    該配列アクセスに対する配列レンジ・チェックの情報を
    そのまま収集し、配列レンジ・チェックにおけるインデ
    ックス変数が正又は負の定数の加算により変更されてい
    る場合には当該インデックス変数に前記定数を加算する
    ことにより生ずる変更を反映させた後の配列レンジ・チ
    ェックの情報を収集するステップと、 深さ優先探索のポストオーダー・トラバーサルの順番
    で、前記第１要処理配列レンジ・チェック情報を伝搬さ
    せ、各ベーシック・ブロックの先頭でバージョニングの
    対象となる配列レンジ・チェックの集合である第２要処
    理配列レンジ・チェック情報を生成し且つ記憶装置に記
    憶する第２要処理配列レンジ・チェック情報生成ステッ
    プであって、あるベーシック・ブロックの前記第１要処
    理配列レンジ・チェック情報と、当該あるベーシック・
    ブロックの後端でバージョニングの対象となる第３要処
    理配列レンジ・チェック情報をインデックス変数の変更
    に応じ変更して生成される第４要処理配列レンジ・チェ
    ック情報との和集合を計算して第２要処理配列レンジ・
    チェック情報を生成するステップと、 前記第２要処理配列レンジ・チェック情報を用いて、ル
    ープの前に前記バージョニングのためのチェック・コー
    ド、及び各実行状態における実行コードを生成し、記憶
    装置に記憶するステップと、 を実行させる、記憶媒体。
31. 【請求項３１】プログラム内の配列アクセスが配列のレ
    ンジを越えていないことを検査するための配列レンジ・
    チェックをプログラム実行とは逆方向に移動させる場合
    に、前記配列レンジ・チェックを変更するプログラムを
    記憶した記憶媒体であって、 前記配列レンジ・チェックを変更するプログラムは、コ
    ンピュータに、 前記配列レンジ・チェックが当該配列のインデックス変
    数に正又は負の定数を加算する処理を越えて移動するこ
    とになるか判断し、前記定数を記憶装置に記憶するステ
    ップと、 前記判断が真である場合には、前記配列レンジ・チェッ
    クにおけるインデックス変数に前記定数を加算すること
    により生じる、前記配列レンジ・チェックの変更を計算
    するステップと、 計算された前記配列レンジ・チェックの変更を反映した
    後の配列レンジ・チェックを記憶装置に記憶するステッ
    プと、 を実行させる、記憶媒体。
32. 【請求項３２】プログラム内の配列アクセスが配列のレ
    ンジを越えていないことを検査するための配列レンジ・
    チェックをプログラム実行と同一方向に移動させる場合
    に、前記配列レンジ・チェックを変更するプログラムを
    記憶する記憶媒体であって、 前記配列レンジ・チェックを変更するプログラムを、コ
    ンピュータに、 前記配列レンジ・チェックが当該配列のインデックス変
    数に正又は負の定数を加算する処理を越えて移動するこ
    とになるか判断し、前記定数を記憶装置に記憶するステ
    ップと、 前記判断が真である場合には、前記配列レンジ・チェッ
    クにおけるインデックス変数に前記定数を減算すること
    により生じる、前記配列レンジ・チェックの変更を計算
    するステップと、 計算された前記配列レンジ・チェックの変更を反映した
    後の配列レンジ・チェックを記憶装置に記憶するステッ
    プと、 を実行させる、記憶媒体。
33. 【請求項３３】プログラム内の配列アクセスが配列のレ
    ンジを越えていないことを検査するための配列レンジ・
    チェックであってチェック済みであるとして取り扱うこ
    とができる配列レンジ・チェックを前記プログラムのベ
    ーシック・ブロック内において収集する配列レンジ・チ
    ェック収集プログラムを記憶した記憶媒体であって、前
    記配列レンジ・チェック収集プログラムは、コンピュー
    タに、 配列レンジ・チェックを検出するステップと、 前記検出された配列レンジ・チェックにおける配列イン
    デックスの最小定数オフセット及び最大定数オフセット
    及び配列の下限から、定数インデックスについてチェッ
    ク済みとして扱うことができる上限及び下限を計算し、
    計算された当該上限及び下限で規定される範囲に関する
    配列レンジ・チェックを記憶装置に記憶するステップ
    と、 を実行させる、記憶媒体。
34. 【請求項３４】プログラム内の配列アクセスが配列のレ
    ンジを越えていないことを検査するための配列レンジ・
    チェックであってチェック済みであるとして取り扱うこ
    とができる配列レンジ・チェックを前記プログラムのベ
    ーシック・ブロック内において収集する配列レンジ・チ
    ェック収集プログラムを記憶した記憶媒体であって、 前記配列レンジ・チェック収集プログラムは、コンピュ
    ータに、 配列レンジ・チェックを検出するステップと、 前記検出された配列レンジ・チェックにおけるインデッ
    クス変数の下限値又は上限値及び配列の下限から、定数
    インデックスについてチェック済みとして扱うことがで
    きる上限及び下限を計算し、計算された当該上限及び下
    限で規定される範囲に関する配列レンジ・チェックを記
    憶装置に記憶するステップと、 を実行させる、記憶媒体。