JP3437932B2 - 配列レンジ・チェックのためのコード生成方法及び装置、並びにバージョニング方法及び装置 - Google Patents

Description

【発明の詳細な説明】

【０００１】

【発明の属する技術分野】本発明は、コンパイラに関
し、より詳しくは、コンパイラにおいて配列レンジ・チ
ェックの回数を減少させてプログラムの実行速度を上げ
る方法に関する。配列レンジ・チェックとは、プログラ
ムにおける配列アクセスがその配列の範囲を越えている
か否かに関する検査である。

【０００２】

【従来の技術】データ・フロー解析（Data-flow analys
is）を用いて配列チェック除去を行う方法（R. Gupta.
Optimizing array bound checks using flow analysis.
ACM Letters on Programming Languages and Systems,
2(1-4): 135-150, March-December 1993.等を参照のこ
と）がある。この方法は、次のような２段階の処理で配
列レンジ・チェックを除去する。すなわち、（１）配列
レンジ・チェックを減らすために実行順の最初の方にチ
ェックを挿入する。（２）不要な配列レンジ・チェック
を除去する。この方法の長所はループ以外の場所につい
ても適用できる点にある。しかし、配列レンジ・チェッ
クを除去できる範囲が狭く、レンジを超えるのは誤りで
あるという仕様の言語にしか適用できないという欠点が
ある。

【０００３】他の従来技術としては、ループ・スプリッ
ティングによるループ変換という方法がある。これはル
ープの下限値のチェック部分、チェック不要部分、上限
値のチェック部分の３つに分ける方法である。例えば、
表１のようなプログラムを表２のように変換するもので
ある。

【表１】

【表２】 このように３つに分けると２つ目のｆｏｒループはレン
ジ・チェックを省略することができる。この方法はこの
例のようにループ内の配列アクセスがシンプルならばコ
ードサイズは３倍になるだけで済むが、配列ベース変数
が複数ある場合については場合分けが多くなり、それに
つれてコードサイズも大きくなるという欠点がある。

【０００４】

【発明が解決しようとする課題】Ｊａｖａ言語（Ｊａｖ
ａはSun Microsystems社の商標）は仕様として配列のレ
ンジを超えたアクセスを検出し、ユーザ定義の例外ハン
ドラが無いときは例外の起きたメソッドを抜けて呼び出
したメソッドへと制御を移し、ユーザが定義した例外ハ
ンドラがあるときにはその例外ハンドラに処理を移すこ
とができる。そのため例外が起きることが正しい動作と
してプログラムが書かれる場合もあるため、配列レンジ
・チェックは必要不可欠である。しかし、配列レンジ・
チェックはレンジ・チェックを必要としない言語と比較
して実行速度の低下を引き起こす。実際のプログラムで
は、レンジを超えたアクセスが無いことを保証できる配
列アクセスが存在し、これらの冗長な配列レンジ・チェ
ックを除去することは性能向上に大きく貢献する。また
例外の発生と配列への値の代入のような副作用を生じる
処理の間の実行順序の保証の観点から、最適化の範囲を
拡大できるればより好ましい。

【０００５】本発明は、より配列レンジ・チェックの回
数を減らし、実行速度を上げることを目的とする。

【０００６】また、複数の配列レンジ・チェックをまと
めた広い配列レンジ・チェックを行い、この広い配列レ
ンジ・チェックが失敗した場合に厳密な配列レンジ・チ
ェックを行うという２段階のチェックを行うことにより
実行時の配列レンジ・チェックの回数を減らし、高速な
実行を可能にする方法を提供することも目的である。

【０００７】さらに、ループ内のどの実行経路を通って
も必ず行われる配列アクセスの情報を用いてバージョニ
ングを実施する方法を提供することも目的である。な
お、バージョニングとは、コンパイル時に、（１）プロ
グラムのある部分のコードが実行される状態をいくつか
に分類し、（２）実行時にその状態を分類するためのチ
ェック・コードと、それぞれの状態に対する、当該プロ
グラムのある部分の実行コードを生成する処理である。

【０００８】

【課題を解決するための手段】配列レンジ・チェックの
回数を減らす本発明は、より広い概念では、複数の配列
レンジ・チェックを統合して、統合された配列レンジ・
チェックのためのコードを生成し、統合された配列レン
ジ・チェックの結果が失敗であった場合のために、複数
の配列レンジ・チェックに含まれる配列レンジ・チェッ
クのためのコードを生成するものである。これらのコー
ドは記憶装置に記憶され、後にプロセッサにより実行さ
れる。このような概念をより具体的にすると、以下の３
つの態様になる。

【０００９】第１の態様においては、プログラム内の配
列アクセスに対する配列レンジ・チェックのためのコー
ドを生成する場合、複数の配列アクセスに対応する複数
の配列レンジ・チェックを統合した統合配列レンジ・チ
ェック（例えば実施例におけるＶＥＲＳＩＯＮ＿ＯＲ
［Ｂ］）の結果を１又は複数の記憶領域（例えばプロセ
ッサのフラグ）に格納する第１コードを生成し且つ記憶
装置（例えばメインメモリ）に記憶する第１ステップ
と、記憶領域を検査し且つ当該記憶領域が統合配列レン
ジ・チェックの成功を示している場合には前記複数の配
列レンジ・チェックに包含される配列レンジ・チェック
のための第２コード（第３コードにより無効化されない
場合には実行しないと正しい実行がなされなくなるよう
な配列レンジ・チェック）を無効化する第３コード（例
えばＰｏｗｅｒＰＣ（InternationalBusiness Machines
Corp. の商標）におけるゼロサイクル・ブランチ命
令）を生成し且つ記憶装置に格納する第２ステップとを
実行する。例えば、フラグをレジスタとして使用できる
プロセッサを使用する場合、高速に第２コードの無効化
を行うことができ、またコードサイズもあまり増やさず
に、配列レンジ・チェックの回数を減らすことができ
る。なお、フラグをレジスタとして使用できるというの
は、フラグの内容を算術命令等によって勝手に壊される
こと無く、そのフラグに保持しておくことができる、と
いうことである。

【００１０】先に示した第１ステップは、複数の配列ア
クセスに対する配列レンジ・チェックを所定の条件に従
って統合し、統合された配列レンジ・チェックの情報を
記憶装置に格納するステップと、統合された配列レンジ
・チェックを記憶領域に割り当てるステップとを含むよ
うにすることができる。

【００１１】本発明の第１の態様においてバージョニン
グを実施する場合、当該バージョニングの条件である統
合配列レンジ・チェックの結果を格納した記憶領域を参
照し且つその記憶領域が統合配列レンジ・チェックの成
功を示している場合には統合配列レンジ・チェックに包
含される配列レンジ・チェックのためのコードを含まな
いバージョンに分岐し且つ記憶領域が統合配列レンジ・
チェックの不成功を示している場合には第２及び第３コ
ードを含むバージョンに分岐するコードを生成し且つ記
憶装置に格納するステップとを、さらに実行する。これ
により、バージョニングの条件である統合配列レンジ・
チェックの不成功の場合でも、従来に比して高速な実行
が可能になる。

【００１２】本発明の第２の態様においては、プログラ
ム内の配列アクセスに対する配列レンジ・チェックのた
めのコードを生成する場合、処理の対象となる、プログ
ラムの第１部分（例えば実施例のＡの部分）に対応し且
つ含まれる配列アクセスに対応して必要な範囲の配列レ
ンジ・チェックを行うための第２部分（例えば実施例の
Ｂの部分）を生成し且つ記憶装置に記憶するステップ
と、第１部分について、例外を発生させる配列レンジ・
チェックをそれより前に移動させることによって副作用
を生じるような命令の存在を無視して配列レンジ・チェ
ックの最適化及び不要な配列レンジ・チェックの除去を
実施し、第１部分のベーシック・ブロックごとに必要と
なる配列レンジ・チェックの情報（又は除去不可能な配
列レンジ・チェック）を記憶装置に記憶するステップ
と、必要となる配列レンジ・チェックを行い且つ当該配
列レンジ・チェックが不成功であった場合に当該不成功
であった配列レンジ・チェックを含むベーシック・ブロ
ックに対応する、第２部分内のベーシック・ブロックに
ジャンプする条件分岐コードを生成し且つ記憶装置に格
納するステップとを実施する。本発明の第２の態様は、
第１の態様が実施できないような場合においても実施す
ることができる。また、本来配列レンジ・チェックが失
敗する配列アクセスが生じるまで、最適化及び不要な配
列レンジ・チェックの除去を行った第１部分を実行する
ので、配列レンジ・チェックの実行回数を減少させるこ
とができる。

【００１３】本発明の第３の態様においては、プログラ
ム内のループのバージョニングを実行する場合、ループ
内のいずれの実行経路を通過したとしても必ず行われる
配列アクセスに対する配列レンジ・チェックの第１集合
情報（実施例においてはＶＥＲＳＩＯＮ＿ＡＮＤ
［Ｂ］）を収集し、収集結果を記憶装置に格納するステ
ップと、収集結果を用いて、バージョニングのための検
査コードを生成し且つ記憶装置に格納するステップと、
収集結果を用いて不要な配列レンジ・チェックを除去
し、除去不可能な配列レンジ・チェックのためのコード
を含む、検査コードによる配列レンジ・チェックが成功
した場合におけるバージョンを生成し且つ記憶装置に格
納するステップと、検査コードによる配列レンジ・チェ
ックが不成功の場合におけるバージョンを生成し且つ記
憶装置に格納するステップとを実行する。これにより、
ループ内において必ず配列レンジ・チェックに失敗する
場合のみ、検査コードによる配列レンジ・チェックが不
成功の場合におけるバージョンを実行することになるの
で、配列レンジ・チェックの実行回数が減ることが期待
できる。

【００１４】上は２バージョンであったが３バージョン
に分けることもでき、この場合には以下のステップを実
行する。すなわち、ループ内のいずれの実行経路を通過
したとしても必ず行われる配列アクセスに対する配列レ
ンジ・チェックに限定せずに配列レンジ・チェックの第
２集合情報（実施例におけるＶＥＲＳＩＯＮ＿ＯＲ
［Ｂ］）を収集し、第２の収集結果を記憶装置に格納す
るステップと、第２集合情報から第１集合情報に含まれ
る配列レンジ・チェックを除去した第３集合情報を用い
て、検査コードによる配列レンジ・チェックが成功した
場合におけるバージョンのさらなるバージョニングのた
めの第２検査コードを生成し且つ記憶装置に格納するス
テップと、第２の収集結果を用いて不要な配列レンジ・
チェックを除去し、除去不可能な配列レンジ・チェック
のためのコードを含む、第２検査コードによる配列レン
ジ・チェックが成功した場合におけるバージョンを生成
し且つ記憶装置に格納するステップとである。なお、検
査コードによる配列レンジ・チェックが成功した場合に
おけるバージョンは、第２検査コードによる配列レンジ
・チェックが不成功であった場合におけるバージョンと
なる。このようにすると、コード量が３倍になるが、元
のコードが少ない場合にはさらに実行時における配列レ
ンジ・チェック回数の削減が期待できる。

【００１５】また本発明の第１の態様と第３の態様は組
み合わせることができ、例えば、２バージョンの場合に
除去不可能な配列レンジ・チェックとインデックス変数
の範囲による配列レンジ・チェックの結果を、生成され
たコードを実行するプロセッサのフラグに格納するため
のコードを生成し且つ記憶装置に格納するステップと、
フラグを検査し且つ当該フラグが除去不可能な配列レン
ジ・チェックの成功を示している場合には除去不可能な
配列レンジ・チェックのためのコードを無効化する他の
コードを生成し且つ記憶装置に格納するステップとをさ
らに実行することも考えられる。これにより、検査コー
ドによる配列レンジ・チェックが成功の場合にフラグの
チェックだけで実際の配列レンジ・チェックが省略でき
る場合もあるため、処理が高速化される。

【００１６】上と同じような効果を得るためにプロセッ
サのフラグを用いる場合、ループ内のいずれの実行経路
を通過したとしても必ず行われる配列アクセスに対する
配列レンジ・チェックに限定せずに配列レンジ・チェッ
クの第２集合情報（実施例においてはＶＥＲＳＩＯＮ＿
ＯＲ［Ｂ］）を収集し、第２の収集結果を記憶装置に格
納するステップと、第２集合情報から第１集合情報に含
まれる配列レンジ・チェックを除去した第３集合情報
（実施例においてはＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］−ＶＥ
ＲＳＩＯＮ＿ＡＮＤ［Ｂ］）の結果を、生成されたコー
ドを実行するプロセッサのフラグに格納するためのコー
ドを生成し且つ記憶装置に格納するステップと、フラグ
を検査し且つ当該フラグが第３集合情報に含まれる配列
レンジ・チェックが成功を示している場合に２バージョ
ンの場合に除去不可能な配列レンジ・チェックのための
コードを無効化する他のコードを生成し且つ記憶装置に
格納するステップとを実行することも考えられる。

【００１７】また、本発明の第１の態様と第３の態様を
バージョニングを行わない場合に組み合わせる時には、
本発明の第１の態様における処理で説明した第１ステッ
プにおいて、プログラムのある部分のいずれの実行経路
を通過したとしても必ず行われる配列アクセスに対する
配列レンジ・チェックの第１集合情報（実施例において
はＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］）を収集し、収集結果
を記憶装置に格納するステップと、ある部分のいずれの
実行経路を通過したとしても必ず行われる配列アクセス
に対する配列レンジ・チェックに限定せずに配列レンジ
・チェックの第２集合情報（実施例においてはＶＥＲＳ
ＩＯＮ＿ＯＲ［Ｂ］）を収集し、第２の収集結果を記憶
装置に格納するステップと、第２集合情報に含まれる配
列レンジ・チェックを１つの記憶領域に割り当て、第２
集合情報から第１集合情報に含まれる配列レンジ・チェ
ックを除去した第３集合情報の配列レンジ・チェックを
１又は複数の記憶領域に割り当てるステップとを実行す
る。これにより効果的に配列レンジ・チェックの除去を
することができる。

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

【００１９】

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

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

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

【００２２】Ａ．フラグをレジスタとして使用できるプ
ロセッサにおいて、範囲の広いレンジ・チェックの結果
をプロセッサのフラグに割り当て、そのフラグを用いて
配列レンジ・チェックのためのコードを無効化する処理 先にも述べたがフラグをレジスタとして使用できると
は、フラグの内容を算術命令等によって勝手に壊される
ことなく、そのフラグに保持しておくことができるとい
う意味である。例えば、Ｍｅｒｃｅｄ（Ｉｎｔｅｌ社の
次世代プロセッサの開発コード名）の述語（Predicat
e）付き実行やＰｏｗｅｒＰＣのゼロサイクル・ブラン
チ命令（Zero Cycle Branch）を利用することを意図し
たものである。但し、これは一例であって同様の機能を
有する他のプロセッサであっても本発明は有効である。

【００２３】では、本処理の大まかな流れを図２を用い
て説明する。まず、複数の配列アクセスに対応する複数
の配列レンジ・チェックを所定の条件に従って統合し、
その結果ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］を記憶装置（例え
ばメインメモリ）に格納する（ステップ１１０）。この
統合のための処理は後に詳しく説明する。図２には示さ
なかったが、このステップ１１０の後に配列レンジ・チ
ェックの最適化処理を実施してもよい。そして、ＶＥＲ
ＳＩＯＮ＿ＯＲ［Ｂ］の配列レンジ・チェックを１又は
複数のフラグに割り当てる（ステップ１２０）。この割
り当てに必要な処理についても後に詳しく説明する。次
に、統合された配列レンジ・チェックの結果を、割り当
てられたフラグに格納するコードを生成し、記憶装置に
格納する（ステップ１３０）。もしバージョニングを実
施する場合（ステップ１４０）には、フラグを用いてバ
ージョニング・ヘッダを生成し、フラグ・チェック成功
のバージョンとフラグ・チェック失敗のバージョンを生
成し且つ記憶装置に格納する（ステップ１５０）。フラ
グ・チェック成功のバージョンとフラグ・チェック失敗
のバージョンはここまででは実質的に同じである。バー
ジョニングを行わない場合（ステップ１４０）又はステ
ップ１５０の後に、メソッド全体に対して、後に詳細に
述べる不要な配列レンジ・チェックの除去と、除去処理
によっても残った、残余の配列レンジ・チェックを包含
する配列レンジ・チェックに対応するフラグを検査し且
つ当該フラグがチェック成功を示している場合には残余
の配列レンジ・チェックのためのコードを無効化するコ
ードを生成し且つ記憶装置に格納する（ステップ１６
０）。なお、最適化処理をステップ１１０の後に実施す
ると、ステップ１６０における不要な配列レンジ・チェ
ックの除去によって除去される配列レンジ・チェックが
少なくなる。

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

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

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

【００２７】backward(C_OUT_OR[B], B)の処理はＡｐｐ
ｅｎｄｉｘ Ａで説明する。

【００２８】ステップ１１０の処理（３）は処理（２）
で作成したＣ＿ＩＮ＿ＯＲ［Ｂ］を用いて次の式による
データ・フロー解析を行い、ＦＬＡＧ＿ＩＮ［Ｂ］及び
ＦＬＡＧ＿ＯＵＴ［Ｂ］を作成する。Ｐ∈Ｐｒｅｄ
（Ｂ）である全てのＰについて FLAG_IN[B] = ∩ FLAG_OUT[P] FLAG_OUT[B] = C_IN_OR[B] ∪ forward(FLAG_IN[B], B) Pred(B)は、Ｂの直前に来る全てのベーシック・ブロッ
クの意味である。上記の式は以下のことを意味してい
る。ベーシック・ブロックＢの直前の全てのベーシック
・ブロックＰの後端における集合ＦＬＡＧ＿ＯＵＴ
［Ｐ］の積集合が集合ＦＬＡＧ＿ＩＮ［Ｂ］となる。そ
して、この集合ＦＬＡＧ＿ＩＮ［Ｂ］をforward(FLAG_I
N[B], B)で処理し、その結果と処理（２）で求めた集合
Ｃ＿ＩＮ＿ＯＲ［Ｂ］との和集合が和集合ＦＬＡＧ＿Ｏ
ＵＴ［Ｂ］となる。

【００２９】forward(FLAG_IN[B], B)の処理はＡｐｐｅ
ｎｄｉｘ Ｂで説明する。

【００３０】ステップ１１０の処理（４）では、次の式
を全てのベーシック・ブロックについて行い、Ｃ＿ＩＮ
＿ＯＲ［Ｂ］内の不要な配列集合情報を削除する。 Ｃ＿ＩＮ＿ＯＲ［Ｂ］＝Ｃ＿ＩＮ＿ＯＲ［Ｂ］−ＦＬＡ
Ｇ＿ＩＮ［Ｂ］

【００３１】ステップ１１０の処理（５）では、処理
（４）で作成したＣ＿ＩＮ＿ＯＲ［Ｂ］を用いて、Ａ．
の処理の対象たるプログラムの部分（例えばループ）内
で不変の配列アクセス、及びループの場合ループ変数の
とりうる範囲が特定できる配列アクセスに関してはルー
プ変数の取り得る範囲を基に、処理の対象たるプログラ
ムの部分（例えばループ）のエントリ・ポイントにおけ
る配列レンジ・チェック集合情報ＶＥＲＳＩＯＮ＿ＯＲ
［Ｂ］を計算する。このＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］
は、バージョニング・ヘッダ内の配列レンジ・チェック
の集合情報である。例えば、ループ変数がｉであって、
取り得る範囲が１以上ｎ未満であることが分かれば、ｕ
ｂ（ａ）についてはｉ＝ｎ−１である場合についてチェ
ックし、ｌｂ（ａ）についてはｉ＝１であるとしてＶＥ
ＲＳＩＯＮ＿ＯＲ［Ｂ］を作成する。このＶＥＲＳＩＯ
Ｎ＿ＯＲ［Ｂ］がＡ．における統合された配列レンジ・
チェックの情報である。

【００３２】次に、図２には示されていない配列レンジ
・チェックの最適化をＡｐｐｅｎｄｉｘ Ｃで説明して
おく。この処理を実施しなくともＡ．の効果はあるが、
より配列レンジ・チェックの数を削減するためにはこの
処理を実施する。なお、この配列レンジ・チェックの最
適化は、バージョニングを実行する前に行う。また、ス
テップ１１０の前に実行してもよい。

【００３３】次にステップ１２０の処理の説明をする。
ステップ１１０において得られたＶＥＲＳＩＯＮ＿ＯＲ
［Ｂ］をフラグに割り振る処理を実施する。すなわち、
以下の擬似コードの処理を実施する。Ａ．の処理の対象
となる、プログラムの部分（例えばループ）に対しては
以下のとおりである。なお、初期的には、 ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］内の配列レンジ・チェック
の数：ｎ 割り当て可能なプロセッサのフラグの最大数：ｆn とする。

【表４】 if (n <= 1 || fn <= 1) { ＜フラグへの割り当て及び配列レンジ・チェックのためのコードの無効化 は行わない。＞ } else { if (n > fn){ ＜VERSION_OR[B]内の配列レンジ・チェックを、処理対象部分における、 対応する配列レンジ・チェックの数でソートする。＞ do { ＜配列レンジ・チェック数の小さいほうから２つの項目を消去し、 その２つの項目及び配列レンジ・チェック数をマージして１つの項目 とし、ソートした配列レンジ・チェック集合情報に挿入する。＞ n--; } while (n > fn); } ＜各フラグに配列レンジ・チェックとループ変数等の範囲チェックの ANDを割り当てる。複数の配列レンジ・チェックがマージされている場合に はそれらのANDを割り当てる。＞ C_IN_OR[B] -= バージョニング・ヘッダとして使用される配列レンジ・チェッ ク; fn -= n; }

【００３４】表４について少し説明しておく。最初のｉ
ｆ文はＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］に含まれる配列レン
ジ・チェックの数が０又は使用可能なフラグの数が０で
ある場合には、表４の処理は意味をなさないので、ここ
で処理を終了する。この条件を満たした場合には、ｎ＞
ｆnであるか否か検査する。言い換えれば、フラグの数
より配列レンジ・チェックの数が多いか検査する。フラ
グの数がＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］内の配列レンジ・
チェックの数より多い場合には、各フラグに、各配列レ
ンジ・チェックとループの場合にはループ変数の範囲チ
ェックとの積（ＡＮＤ）を割り当てる。一方、フラグの
数がＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］内の配列レンジ・チェ
ックの数より少ない場合には、１つのフラグに対して、
ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］内の配列レンジ・チェック
を幾つかまとめて割り当てなければならない。そこで、
ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］内の配列レンジ・チェック
を、処理対象部分（例えばループ）における、対応する
配列レンジ・チェックの数でソートする。そして、以下
の処理を、マージしてできた配列レンジ・チェック集合
情報内の項目数がフラグの数より小さくなるまで、繰り
返す。この処理とは、配列レンジ・チェック数の小さい
ほうから２つの項目を消去し、その２つの項目及び配列
レンジ・チェック数をマージして１つの項目とし、ソー
トした配列レンジ・チェック集合情報に挿入する処理で
ある。よって、この処理が終了すると、複数の配列レン
ジ・チェックがマージされている場合には、それらの配
列レンジ・チェックの積（ＡＮＤ）（ループの場合には
ループ変数の範囲チェックとの積）をフラグに割り当て
る。後続の処理のために、Ｃ＿ＩＮ＿ＯＲ［Ｂ］からバ
ージョニング・ヘッダとして使用される配列レンジ・チ
ェック（殆どの場合ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］そのも
の）を取り除く処理を実施する。殆どの場合Ｃ＿ＩＮ＿
ＯＲ［Ｂ］は空になる。

【００３５】また、この後に全てのベーシック・ブロッ
クに対して次の処理を行う。なお、全てのＣ＿ＩＮ＿Ｏ
Ｒ［Ｂ］の和（ＯＲ）としてＡＬＬ＿ＦＬＡＧという集
合を作成する。この集合情報は、各項目について配列レ
ンジ・チェック情報に加えてそのベーシック・ブロック
番号を有している。 ALL_FLAG = ∪ C_IN_OR[B] また、初期的には、 ALL_FLAGの配列レンジチェック集合情報の項目数 ： ｎ 割り当て可能なプロセッサの最大フラグ数 ： ｆn とする。

【表５】 if (fn <= 0) { ＜フラグへの割り当て及び配列レンジ・チェックの無効化は行わない。＞ } else { ＜ALL_FLAGの配列レンジ・チェック集合情報を、対応する配列レンジ・ チェックの数でソートし、配列レンジ・チェック数が１以下の要素を 削除する。＞ while (n > fn){ ＜配列レンジ・チェック数の小さいほうからベーシック・ブロックが 同一の２つの項目を消去し、その２つの項目及びレンジ・チェック数 をマージして１つの項目とし、ソートした配列レンジ・チェック集合 情報に挿入する。＞ if (マージできる項目が無かった) { n = fn; break; } n--; } ＜各フラグに配列レンジ・チェック数が多い項目から配列レンジ・チェック 集合情報内の配列レンジ・チェックを割り当てる。 複数の配列レンジ・チェックがマージされている場合にはそれらのANDを を割り当てる。＞ ALL_FLAG -= フラグを割り当てられなかった配列レンジ・チェック fn -= n; }

【００３６】表５の処理を大まかに説明しておく。表５
は余ったフラグを用いて、配列レンジ・チェックの数を
さらに減少させるための処理である。表４等の処理で割
り当て可能なフラグが０になってしまえば、表５の処理
は行われない。もし割り当て可能なフラグが存在してい
るならば、ＡＬＬ＿ＦＬＡＧの中でマージを試みる。そ
のため、表４でも行われているように、ＡＬＬ＿ＦＬＡ
Ｇの配列レンジ・チェックを、対応する配列レンジ・チ
ェックの数でソートする。この時、配列レンジ・チェッ
クの数が１以下であるものにフラグを割り当てても効果
がないので、１以下のものは破棄される。そして、配列
レンジ・チェックの数が小さい方から、ベーシック・ブ
ロックが同一の項目を消去し、その２つの項目及びレン
ジ・チェック数をマージして１つの項目とし、ソートし
た配列レンジ・チェック集合情報に挿入する。これを集
合情報に含まれる項目がフラグの数以下になるまで繰り
返す。但し、同じベーシック・ブロックの項目がないと
マージできないので、マージできない場合には、そこで
繰り返し処理を中止する。そして、各フラグに配列レン
ジ・チェック数が多い項目から配列レンジ・チェックを
割り当てる。複数の配列レンジ・チェックがマージされ
ている場合にはそれらの積（ＡＮＤ）を割り当てる。最
後に、ＡＬＬ＿ＦＬＡＧからフラグに割り当てられなか
った配列レンジ・チェックを取り除いておく。これは後
の処理で用いられる。

【００３７】以上のような処理にてＶＥＲＳＩＯＮ＿Ｏ
Ｒ［Ｂ］の配列レンジ・チェックを各フラグに割り当て
る。なお、以上の割り当て方法は一例であって他の方法
にて割り当てることも可能である。さらに表５の処理は
実施しなくともよい。

【００３８】次にステップ１３０の説明をする。ここで
は、ステップ１２０の結果により、Ａ．の処理に必要な
最初のコードを生成する。すなわち、各フラグに、ステ
ップ１２０によりそのフラグに割り当てられた配列レン
ジ・チェック集合情報の項目の配列レンジ・チェックの
結果を格納するためのコードを生成する。１つのフラグ
に多数の配列レンジ・チェックが割り当てられた場合に
は、それらの配列レンジ・チェックの結果がＡＮＤされ
てそのフラグに格納されるようなコードが生成される。

【００３９】ステップ１４０は単純な場合分けであるか
らこれ以上述べない。Ａ．の処理は、ループなどのバー
ジョニングを行わない場合にも適用可能である。

【００４０】バージョニングを行う場合には、ステップ
１５０に遷移する。ここでは、まずバージョニング・ヘ
ッダを生成する。このバージョニング・ヘッダとは、ど
のバージョンへジャンプするかの判断を行う場所であ
る。ここでは、ステップ１３０でバージョニング・ヘッ
ダとなるＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］の配列レンジ・チ
ェックの結果は割り当てのあったフラグに格納されてい
ることになるので、それらのフラグをチェックするコー
ドを生成する。割り当てのあった全てのフラグが配列レ
ンジ・チェック成功を示している場合には、成功の場合
のバージョンへジャンプし、不成功を示している場合に
は、１つでも不成功の場合のバージョンへジャンプする
ためのコードも生成する。

【００４１】次に実際に配列レンジ・チェック成功の場
合のバージョンのためのコードと、不成功の場合のバー
ジョンのためのコードを生成する。但し、これらのバー
ジョンはこの段階では実質的に同じものである。すなわ
ち、両バージョンとも、最適化の処理を実施していない
場合には、個々の配列アクセスに対して１つの必要十分
な配列レンジ・チェックを含んでいる。最適化の処理を
実施した場合には、各ベーシック・ブロックごとにその
ベーシック・ブロックに含まれる全ての配列アクセスに
対し、必要な配列レンジ・チェックが生成されている。

【００４２】ステップ１６０では、主に不要な配列レン
ジ・チェックの除去を実施する。それと同時に、除去さ
れなかった、残余の配列レンジ・チェックを包含する配
列レンジ・チェックのフラグを検査し且つ当該フラグが
配列レンジ・チェック成功を示している場合残余の配列
レンジ・チェックのためのコードを無効化するコードを
生成する。この不要な配列レンジ・チェックの除去処理
の詳細はＡｐｐｅｎｄｉｘ Ｄに記載してある。但し、
ステップ３２０の処理を以下のように変更する。すなわ
ち、ＡＬＬ＿ＦＬＡＧからベーシック・ブロックＢの要
素を抜き出した部分集合ＡＬＬ＿ＦＬＡＧ［Ｂ］を新た
に定義し、Ｃ＿ＧＥＮ［Ｂ］，Ｃ＿ＩＮ［Ｂ］，Ｃ＿Ｏ
ＵＴ［Ｂ］，ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］及びＡＬＬ＿
ＦＬＡＧ［Ｂ］内の各配列レンジ・チェックにつき、ベ
ース変数、インデックスのインデックス変数の項、最小
定数オフセット、最大定数オフセット、及び対応するフ
ラグ名を記憶する。なお、Ｃ＿ＧＥＮ［Ｂ］の各配列レ
ンジ・チェックについては［対応するフラグ名］には
［なし］を記憶し、ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］及びＡ
ＬＬ＿ＦＬＡＧ［Ｂ］の各配列レンジ・チェックには上
で述べたステップ１３０で割り当てられたフラグ名を記
憶する。そして、次の式によるデータ・フロー解析を実
施する。ベーシック・ブロックＢが初期ブロックでない
場合、Ｂに先行する全てのＰについて、 C_IN[B] = (∩ C_OUT[P]) ∪ VERSION_OR[B] ∪ ALL_FL
AG[B] ベーシック・ブロックＢが初期ブロックである場合、 C_IN[B] = VERSION_OR[B] ∪ ALL_FLAG[B] C_OUT[B] = C_GEN[B] ∪ forward(C_IN[B],B) 少し説明しておくと、ベーシック・ブロックＢが初期ブ
ロックでない場合には、Ｂに先行する全てのＰについて
Ｃ＿ＯＵＴ［Ｐ］の積集合を求め、その結果とＶＥＲＳ
ＩＯＮ＿ＯＲ［Ｂ］とＡＬＬ＿ＦＬＡＧ［Ｂ］との和集
合がＣ＿ＩＮ［Ｂ］となる。一方、ベーシック・ブロッ
クＢが初期ブロックである場合には、Ｃ＿ＯＵＴ［Ｐ］
がないので、ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］とＡＬＬ＿Ｆ
ＬＡＧ［Ｂ］との和集合がＣ＿ＩＮ［Ｂ］となる。この
Ｃ＿ＩＮ［Ｂ］にＡｐｐｅｎｄｉｘ Ｂで説明している
ｆｏｒｗａｒｄ処理を実施し、その結果とＣ＿ＧＥＮ
［Ｂ］の和集合がＣ＿ＯＵＴ［Ｂ］となる。

【００４３】また、Ａｐｐｅｎｄｉｘ Ｄのステップ３
３０も以下のように変更する。

【表６】 for (各ベーシック・ブロックについて実行順に命令を取り出す){ switch(命令){ 配列アクセス命令: その配列レンジ・チェックＣに対して if (ＣがC_IN[B]からチェック済と判断できる){ if (C_IN[B]内のＣを含む部分集合内に［対応するフラグ名］が ［無し］の配列レンジ・チェックがある）{ /* C_GENから流れてきた配列レンジ・チェックがある */ 配列レンジ・チェックＣを除去; } else { [対応するフラグ名］の結果により配列レンジ・チェック Ｃを無効化するコードを生成する。 } } 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; } }

【００４４】Ａｐｐｅｎｄｉｘ Ｄの表３０と異なるの
は、ベーシック・ブロックＢ内の配列アクセス命令を取
り出した時の処理である。ここではＣ＿ＩＮ［Ｂ］で配
列レンジ・チェックＣがチェック済みであると判断でき
る場合でも、もう一つの検査に従って場合分けを行う。
すなわち、Ｃ＿ＩＮ［Ｂ］内の、Ｃが含まれる部分集合
がＣ＿ＧＥＮ［Ｂ］から加わった配列レンジ・チェック
である場合、すなわち、その部分集合の［対応するフラ
グ名］が［無し］である場合には、配列レンジ・チェッ
クＣを除去し、そうでない場合には、その配列レンジ・
チェックＣを［対応するフラグ名］のフラグが配列レン
ジ・チェックが成功したことを示している場合には無効
化するコードを生成する。

【００４５】より具体的に、Ｍｅｒｃｅｄの述語（Pred
icate）付き命令を利用する場合を図３及び図４を用い
て説明する。ここでは、図３のように、命令１乃至３は
無条件に実行されるが、ＦＬＡＧ１が真（ＴＲＵＥ）で
あれば配列レンジ・チェックのためのコード１．１乃至
１．３を実行する。ＦＬＡＧ１が真でない場合又はコー
ド１．３を実行した後に、命令４以降を実行する。この
時、Ｍｅｒｃｅｄでは、図４のように命令を実行する。
すなわち、図４の太枠が１つの命令であって、命令内の
左のフィールドがＦＬＡＧ１と書いてある命令はＦＬＡ
Ｇ１がＴＲＵＥの時に命令を実行し、ＦＬＡＳＥの場合
には命令を実行しないことを意味している。左のフィー
ルドが空欄である場合には、その命令は無条件に実行さ
れる。なお、図４の各命令は、通常１行（３命令）を１
サイクルで実行されるが、ここでは図３の順番で１つず
つ実行される。

【００４６】また、ＰｏｗｅｒＰＣのゼロサイクル・ブ
ランチ命令を利用する場合には、割り当てられたフラグ
がＴＲＵＥの時フラグに対応する配列レンジ・チェック
をスキップするコードを生成する。例えば割り当てられ
たフラグがＢｉｔ５だとしたら次のようなコードを生成
してスキップする。 bbt 5, SKIP 配列レンジ・チェックのためのコード SKIP:ｂｂｔはＢｉｔ「５」がＴＲＵＥだったらＳＫＩ
Ｐへジャンプし、そうでなければ、下の配列レンジ・チ
ェックのためのコードを実行するものである。

【００４７】このようにして、ステップ１６０の処理が
不要な配列レンジ・チェックの除去の処理と共に実施さ
れる。

【００４８】では、具体例をもってＡ．の処理を説明す
る。

【表７】 i = 0; while(i < n-2){ t = sub1[i] / diag[i]; diag[i + 1] -= t * sup1[i]; sup1[i + 1] -= t * sup2[i]; b [i + 1] -= t * b [i]; t = sub2[i] / diag[i]; sub1[i + 1] -= t * sup1[i]; diag[i + 2] -= t * sup2[i]; b [i + 2] -= t * b [i]; i++; } これは５重対角な連立方程式を解くアルゴリズムの一部
分を抜き出したものである。なお、ｌｂ（ａ）とは配列
ａの下限値、ｕｂ（ａ）とは配列ａの上限値を指してい
る。また、ｃｈｅｃｋ( )とは括弧内の配列レンジ・チ
ェックが行われることを意味する。さらに、Ｊａｖａ言
語では配列の下限は０と決まっているので、以下このこ
とを使用する。

【００４９】ステップ１１０の処理を実施すると、ＶＥ
ＲＳＩＯＮ＿ＯＲ［Ｂ］は check(n-1 <= ub(diag)) check(n-1 <= ub(b)) check(n-2 <= ub(sub1)) check(n-2 <= ub(sup1)) check(n-3 <= ub(sub2)) check(n-3 <= ub(sup2)) となる。なお、ループ変数の範囲のチェックは、0 <= n
-3である。

【００５０】なお、最適化を実施すると、

【表８】 i = 0; while(i < n-2){ check(i <= ub(sub1)); check(i <= ub(diag)); t = sub1[i] / diag[i]; check(i+1 <= ub(diag)); check(i <= ub(sup1)); diag[i + 1] -= t * sup1[i]; check(i+1 <= ub(sup1)); check(i <= ub(sup2)); sup1[i + 1] -= t * sup2[i]; check(i+1 <= ub(b)); b[i + 1] -= t * b[i]; check(i <= ub(sub2)); t = sub2[i] / diag[i]; check(i+1 <= ub(sub1)); sub1[i + 1] -= t * sup1[i]; check(i+2 <= ub(diag)); diag[i + 2] -= t * sup2[i]; check(i+2 <= ub(b)); b[i + 2] -= t * b[i]; i++; }

【００５１】ステップ１２０の処理で、まず表８の結果
からＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］のソートを行うと、以
下のようになる。 チェック命令 レンジチェック数 n-1 <= ub(diag) ３回 n-1 <= ub(b) ２回 n-2 <= ub(sub1) ２回 n-2 <= ub(sup1) ２回 n-3 <= ub(sub2) １回 n-3 <= ub(sup2) １回 これをステップ１２０の処理でプロセッサのフラグ４つ
（flag1からflag4とする)に割り振るとすると次のよう
になる。

【表９】 フラグ フラグに対応する配列レンジ・チェック レンジチェック数 flag1 0 <= n-3 && n-2 <= ub(sub1) && n-2 <= ub(sup1) ４回 flag2 0 <= n-3 && n-1 <= ub(diag) ３回 flag3 0 <= n-3 && n-1 <= ub(b) ２回 flag4 0 <= n-3 && n-3 <= ub(sub2) && n-3 <= ub(sup2) ２回

【００５２】表９を用いてステップ１３０では、以下の
ようなコードが生成される。

【表１０】 なお、

【表１１】 flag1 = (n-2 <= ub(sub1) && n-2 <= ub(sup1) && 0 <= n-3); flag2 = (n-1 <= ub(diag) && 0 <= n-3); flag3 = (n-1 <= ub(b) && 0 <= n-3); flag4 = (n-3 <= ub(sub2) && n-3 <= ub(sup2) && 0 <= n-3); としてもよい。

【００５３】ステップ１５０の処理を実施すると、

【表１２】

【００５４】最後にステップ１６０を実施すると、以下
のようになる。

【表１３】 例えば「if (!flag3) check(i+2 <= ub(b));」がフラグ
を検査し且つフラグに割り当てられた配列レンジ・チェ
ックがチェック成功を示している場合にはcheck(i+2 <=
ub(b))を無視するコードである。

【００５５】本発明はステップ１４０から明らかなよう
にバージョニングを用いない場合であっても適用可能で
ある。すなわち、表７は、以下のようになる。

【表１４】

【００５６】さらに、Ａ．の処理はループでなくとも適
用可能であり、例えば表７のwhile文が無くとも、同じ
ようにフラグのチェックだけで実際の配列レンジ・チェ
ックを行わずに済み、高速化される場合もある。

【００５７】Ｂ．副作用を起こす命令の存在を考慮せず
に配列レンジ・チェックをできるかぎりまとめる処理 Ａ．の処理はプロセッサのフラグを上記のように使用で
きる場合に主に適用できる。また、バージョニングでき
ないような場合も存在する。本処理Ｂは処理Ａが使用で
きないような場面で有効である。図５に本処理Ｂ．のフ
ローを示す。まず、本処理が適用される部分Ａを複製
し、対応するプログラム部分Ｂを作成し且つ記憶装置に
格納する（ステップ４１０）。次に、配列レンジ・チェ
ックの最適化処理（Ａｐｐｅｎｄｉｘ Ｃ）を施す。但
し、Ａｐｐｅｎｄｉｘ Ｃに述べられた処理は、副作用
を起こす可能性のある命令が存在するか否かを考慮して
行われるが、ここでは、このような副作用を起こす可能
性のある命令の存在は考慮しない。Ａｐｐｅｎｄｉｘ
Ｃと異なる点は、表２５及び表２６においてＣ＿ＧＥＮ
［Ｂ］又はＣ＿ＯＵＴ［Ｂ］をφにする処理を行わない
という点である。その後に、プログラム部分Ａについて
配列レンジ・チェックの除去処理を実施する（ステップ
４３０）。この除去処理は、Ａｐｐｅｎｄｉｘ Ｄで説
明された処理である。そして、プログラム部分Ａ内に残
った配列レンジ・チェックに失敗した場合にその失敗し
た配列レンジ・チェックを含むベーシック・ブロックに
対応する、プログラム部分Ｂ内のベーシック・ブロック
にジャンプする条件分岐命令を生成し且つ記憶装置に格
納する（ステップ４４０）。その後全体のコントロール
フロー・グラフを再構成し、その際本処理適用部分のエ
ントリ・ポイントをＡに設定する（ステップ４５０）。
本願に関係する部分はこれで終わるが、この後に再構成
したコントロールフロー・グラフを基にＡ及びＢについ
て従来から行われているレジスタ割り当て及びコード生
成を行う。

【００５８】以上のような処理を実施すると、副作用を
起こす命令を考慮せずに配列レンジ・チェックを集める
ことができるため、配列レンジ・チェック数を減らすこ
とができる。そのため、配列レンジ・チェックを失敗す
ることによって生じる例外が実行時には発生しない場
合、Ａのみ実行されるために実行が高速化される。ま
た、例外が実際に起こる場合にも配列レンジ・チェック
の最適化を行わないＢのコードが実行され、正しい場所
で例外が起こるために副作用を起こす命令に関する問題
が生じない。また、ループ内で例外が起こる場合（例え
ば、配列に初期値を順番に入力する場合に、配列のレン
ジを超えるような回数のループを設け、配列のレンジを
超えるような配列アクセスを生じさせて、初期値入力を
終了させるようなプログラムの場合）でも実際に例外が
起こるループの最後の実行時のみＢに制御が移る。よっ
て、それまでのループの実行はＡ内で動作するため、ル
ープ全体の実行速度を上げることができる。

【００５９】では、上記処理の適用例を示す。以下のよ
うなプログラムに本処理を適用する。

【表１５】

【００６０】表１５はｉの範囲が定まらないので、ルー
プのバージョニングを行うことができない。このプログ
ラムに対して、Ａｐｐｅｎｄｉｘ Ｃの最適化処理を行
うとｃａｓｅ １乃至３はその配列アクセスが副作用を
生じる可能性があるので、これを越えて配列レンジ・チ
ェックをまとめることができない。ステップ４１０乃至
ステップ４３０を実行すると、以下のようになる。

【表１６】 なお、例えばｃａｓｅ ３の場合、Ａｐｐｅｎｄｉｘ
Ｃの最適化処理を実施した場合と、処理Ｂ．で修正した
最適化処理を実施する場合とでは以下の差が出る。 なお、括弧内の意味は、左から順番に配列ベース変数、
インデックスの変数の項、最小定数インデックス、最大
定数インデックス変数である。最適化処理で最終的に使
用されるのはＣ＿ＩＮ［Ｂ］である。処理Ｂ．の方が、
最大定数インデックス変数が大きくなっているので、多
くの配列インデックスがまとめられる。この後、不要な
配列インデックスの除去の処理でも、Ｃ＿ＩＮ［Ｂ］が
計算される。ｃａｓｅ ３のＣ＿ＩＮ［Ｂ］の場合に
は、上の結果と同じになり、プログラム部分Ａのｉ＋１
からｉ＋４の間の配列レンジ・チェックは除去される。

【００６１】最後に、ステップ４４０以降の処理を実施
すると、以下のようになる。

【表１７】 /* Entry Point */ i = 0; while(TRUE){ check(i <= ub(a)); switch(a[i]){ case 1: if (i+2 > ub(a)) goto EXACT_CHECK1; --- (1) a[i+1] = 5; i += 2; break; case 2: if (i+3 > ub(a)) goto EXACT_CHECK2; --- (2) a[i+1] = 10; a[i+2] = 20; i += 3; break; case 3: if (i+4 > ub(a)) goto EXACT_CHECK3; --- (3) a[i+1] = 100; a[i+2] = 200; a[i+3] = 300; i += 4; break; default: System.err.println("error!"); case 0: return; } } return; /* (1),(2),(3)について実際に例外を発生させる部分 */ i = 0; while(TRUE){ check(i <= ub(a)); switch(a[i]){ case 1: EXACT_CHECK1: --- (4) check(i+1 <= ub(a)); a[i+1] = 5; i += 2; break; case 2: EXACT_CHECK2: --- (5) check(i+1 <= ub(a)); a[i+1] = 10; check(i+2 <= ub(a)); a[i+2] = 20; i += 3; break; case 3: EXACT_CHECK3: --- (6) check(i+1 <= ub(a)); a[i+1] = 100; check(i+2 <= ub(a)); a[i+2] = 200; check(i+3 <= ub(a)); a[i+3] = 300; i += 4; break; default: System.err.println("error!"); case 0: return; } } return; （１）乃至（３）がステップ４４０で生成されるコード
である。表１６とは、配列レンジ・チェックが失敗した
ら、プログラム部分Ｂにジャンプするということで、条
件が不等式が異なっている。

【００６２】Ｃ．ループ内のどの実行経路を通っても必
ず行われる配列アクセスに対する配列レンジ・チェック
情報を使用してバージョニングする処理 ループ内のどの実行経路を通っても必ず行われる配列ア
クセスに対する配列レンジ・チェック情報を使ってバー
ジョニングをすると、実際に配列レンジ・チェックで例
外が発生する場合以外は厳密な配列レンジ・チェックを
行うバージョンに遷移するのを防ぐことができる。以
下、本方法の処理フローを図６を用いて説明する。

【００６３】まず、バージョニングを行うループ内のど
の実行経路を通過しても必ず行われる配列アクセスに対
する配列レンジ・チェック集合情報ＶＥＲＳＩＯＮ＿Ａ
ＮＤ［Ｂ］を、バージョニングを行うループのエントリ
・ポイントで生成する（ステップ５１０）。なお、この
ＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］は、記憶装置に記憶され
る。そして、このＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］を用い
てバージョニング・ヘッダを生成し且つ記憶装置に格納
する（ステップ５２０）。この後、バージョンニング・
ヘッダにおける配列レンジ・チェックが成功した場合の
バージョンと、失敗した場合のバージョンとを生成し、
記憶装置に格納する（ステップ５３０）。これらは、こ
の時点では実質的に同一である。但し、先ほど述べたＶ
ＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］は成功した場合のバージョ
ンのループのエントリ・ポイントで有効であり、失敗し
た場合のバージョンの場合にはφである。このような状
態で、不要な配列レンジ・チェックの除去処理を実施す
る（ステップ５４０）。このようにすると、バージョニ
ング・ヘッダの配列レンジ・チェックが成功した場合の
バージョンではどの実行経路を通過しても必ず行われる
配列アクセスに対する配列レンジ・チェックは除去され
るが、失敗した場合のバージョンでは重複する配列レン
ジ・チェックのみが除去されるのみであり、成功した場
合のバージョンの実行速度が速くなる。

【００６４】図６の処理では、バージョニング・ヘッダ
の配列レンジ・チェックが成功した場合のバージョンだ
けでなく失敗した場合のバージョンでも配列レンジ・チ
ェックの除去処理を行っているが、成功した場合のバー
ジョンのみ除去処理を行ってもよい。成功した場合のバ
ージョンは配列レンジ・チェックが大幅に減少するの
で、実行速度が速くなる。

【００６５】では、図６の各ステップを詳しく説明す
る。まず、ステップ５１０では、ＶＥＲＳＩＯＮ＿ＡＮ
Ｄ［Ｂ］を求める。Ａ．の処理ではＶＥＲＳＩＯＮ＿Ｏ
Ｒ［Ｂ］を求めていたが、ここでは、Ａ．の処理の和集
合を取っていたある部分で積集合を取る。

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

【００６７】次にステップ５１０の処理（２）について
説明する。このステップ５１０の処理（２）では、上で
収集したＣ＿ＧＥＮ［Ｂ］を用いて、次の式によるデー
タ・フロー解析を実行し、Ｃ＿ＩＮ＿ＡＮＤ［Ｂ］を求
める。 Ｓ∈ Succ(B) である全てのＳについて、 C_OUT_AND[B] = ∩ C_IN_AND[S] C_IN_AND[B] = C_GEN[B] ∪ backward(C_OUT_AND[B], B) Succ(B)は、Ｂの直後に来る全てのベーシック・ブロッ
クの意味である。上の式は以下のことを示している。あ
るベーシック・ブロックＢの後端における、配列レンジ
・チェックの集合Ｃ＿ＯＵＴ＿ＡＮＤ［Ｂ］には、Ｓ∈
Succ(B)である全てのベーシック・ブロックＳの先頭に
おける、配列レンジ・チェックの集合Ｃ＿ＩＮ＿ＡＮＤ
［Ｓ］の積集合を計算した結果を代入する。また、Ｃ＿
ＯＵＴ＿ＡＮＤ［Ｂ］は後に述べる処理により、ベーシ
ック・ブロックＢにおいて行われる配列インデックスに
対する変更に応じて所定の修正が行われ、新たに集合ba
ckward(C_OUT_AND[B], B)となる。この集合backward(C_
OUT_AND[B], B)及び先に求めたＣ＿ＧＥＮ［Ｂ］の和集
合がＣ＿ＩＮ＿ＡＮＤ［Ｂ］となる。最終的に必要なの
はこのＣ＿ＩＮ＿ＡＮＤ［Ｂ］である。

【００６８】backward(C_OUT_AND[B], B)の処理はＡｐ
ｐｅｎｄｉｘ Ａと同じである。但し、Ａｐｐｅｎｄｉ
ｘ ＡではＣ＿ＩＮ＿ＯＲ［Ｂ］であったが、これをＣ
＿ＩＮ＿ＡＮＤ［Ｂ］に置き換える。

【００６９】ステップ５１０の処理（３）は処理（２）
で作成したＣ＿ＩＮ＿ＡＮＤ［Ｂ］を用いて次の式によ
るデータ・フロー解析を行い、ＦＬＡＧ＿ＩＮ［Ｂ］を
作成する。Ｐ∈Ｐｒｅｄ（Ｂ）である全てのＰについて FLAG_IN[B] = ∩ FLAG_OUT[P] FLAG_OUT[B] = C_IN_AND[B] ∪ forward(FLAG_IN[B],
B) Pred(B)は、Ｂの直前に来る全てのベーシック・ブロッ
クの意味である。上記の式は以下のことを意味してい
る。ベーシック・ブロックＢの直前の全てのベーシック
・ブロックＰの後端の集合ＦＬＡＧ＿ＯＵＴ［Ｐ］の積
集合が集合ＦＬＡＧ＿ＩＮ［Ｂ］となる。そして、この
集合ＦＬＡＧ＿ＩＮ［Ｂ］をforward(FLAG_IN[B], B)で
処理し、その結果と処理（２）で求めた集合Ｃ＿ＩＮ＿
ＡＮＤ［Ｂ］との和集合が和集合ＦＬＡＧ＿ＯＵＴ
［Ｂ］となる。

【００７０】forward(FLAG_IN[B], B)の処理はＡｐｐｅ
ｎｄｉｘ Ｂと同じである。

【００７１】ステップ５１０の処理（４）では、次の式
を全てのベーシック・ブロックについて行い、Ｃ＿ＩＮ
＿ＡＮＤ［Ｂ］内の不要な配列集合情報を削除する。Ｃ
＿ＩＮ＿ＡＮＤ［Ｂ］＝Ｃ＿ＩＮ＿ＡＮＤ［Ｂ］−ＦＬ
ＡＧ＿ＩＮ［Ｂ］

【００７２】ステップ５１０の処理（５）では、処理
（４）で作成したＣ＿ＩＮ＿ＡＮＤ［Ｂ］を用いて、ル
ープ内で不変の配列アクセス、及びループ変数の取り得
る範囲が特定できる配列アクセスに関してはループ変数
の取り得る範囲を基に、ループのエントリ・ポイントに
おける配列レンジ・チェック集合情報ＶＥＲＳＩＯＮ＿
ＡＮＤ［Ｂ］を計算する。このＶＥＲＳＩＯＮ＿ＯＲ
［Ｂ］がバージョニング・ヘッダー内の配列レンジ・チ
ェックとなる。例えば、ループ変数がｉであって、取り
得る範囲が１以上ｎ未満であることが分かれば、ｕｂ
（ａ）についてはｉ＝ｎ−１である場合についてチェッ
クし、ｌｂ（ａ）についてはｉ＝１であるとしてＶＥＲ
ＳＩＯＮ＿ＡＮＤ［Ｂ］を作成する。このＶＥＲＳＩＯ
Ｎ＿ＡＮＤ［Ｂ］、ステップがステップ５１０における
出力となる。

【００７３】次に、ステップ５２０であるが、Ａ．の処
理でＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］を用いてバージョニン
グ・ヘッダを作成したが、それと同じで、ここではＶＥ
ＲＳＩＯＮ＿ＡＮＤ［Ｂ］を用いてバージョニング・ヘ
ッダを作成する。

【００７４】ステップ５３０の処理は、実質的にバージ
ョニング対象となるループのコピーを行うものである。
但し、バージョニング・ヘッダの配列レンジ・チェック
が失敗した場合のバージョンについては、ＶＥＲＳＩＯ
Ｎ＿ＡＮＤ［Ｂ］は空である。

【００７５】ステップ５４０では、不要な配列レンジ・
チェックの除去を実施する。これは基本的には、Ａｐｐ
ｅｎｄｉｘ Ｄに記載されている配列レンジ・チェック
の処理を実施する。但し、図１４のステップ３２０の処
理は以下のように変更する。すなわち、ステップ３２０
で次の式によるデータ・ブロー解析を行う。全てのＰ∈
Pred(B)について、Ｂが初期ブロックでない場合、 C_IN[B] = （∩ C_OUT[P]）∪VERSION_AND[B] Ｂが初期ブロックである場合、 C_IN[B] = VERSION_AND[B] C_OUT[B] = C_GEN[B] ∪ forward(C_IN[B], B) これらの説明を少ししておくと、ベーシック・ブロック
Ｂに先行する全てのベーシック・ブロックＰについて、
もしベーシック・ブロックＢが初期ブロックでなけれ
ば、Ｃ＿ＯＵＴ［Ｐ］の積集合を求め、その結果とＶＥ
ＲＳＩＯＮ＿ＡＮＤ［Ｂ］との和集合をＣ＿ＩＮ［Ｂ］
として計算する。一方、ベーシック・ブロックが初期ブ
ロックである場合には、Ｃ＿ＩＮ［Ｂ］はＶＥＲＳＩＯ
Ｎ＿ＡＮＤ［Ｂ］と同じである。そして、Ｃ＿ＯＵＴ
［Ｂ］はＣ＿ＧＥＮ［Ｂ］とforward(C_IN[B], B)で計
算される。forward(C_IN[B], B)は、Ａｐｐｅｎｄｉｘ
Ｂの処理で計算できる。但し、FLAG_IN[B]をC_IN[B]に
置き換える。

【００７６】これ以外の処理はＡｐｐｅｎｄｉｘ Ｄと
同じである。よって、この処理が終了したところで、バ
ージョニング・ヘッダにおける配列レンジ・チェックが
成功した場合のバージョンは、バージョニングを行うル
ープ内のある実行経路でしか実行されない配列レンジ・
チェックについては残るが、他の配列レンジ・チェック
はほとんど除去されるので、配列レンジ・チェックの回
数が減少する。一方、失敗した場合のバージョンでは、
重複する配列レンジ・チェックのみ除去される。

【００７７】以上の処理の具体的例を以下に説明する。
例えば、以下のようなプログラムに処理を実施する。

【表１８】

【００７８】ステップ５１０を実施すると、ＶＥＲＳＩ
ＯＮ＿ＡＮＤ［Ｂ］は以下のようになる。 よって、ステップ５２０のバージョニング・ヘッダは以
下のようになる。

【００７９】ステップ５３０及びステップ５４０を実施
すると以下のようになる。

【表１９】

【００８０】表１９を見ればよく分かるように、バージ
ョニング・ヘッダにおける配列レンジ・チェックが成功
した場合には、ループ内の配列レンジ・チェックは１つ
になる。一方、失敗した場合には、多数の配列レンジ・
チェックが必要となっている。

【００８１】本処理Ｃ．は処理Ａ．と組み合わせて実施
することも可能である。その例が表１９の（１）であ
る。このためには、２つの方法が考えられる。１つの方
法は、ステップ５４０の不要な配列レンジ・チェックの
除去処理後に、バージョニング・ヘッダにおける配列レ
ンジ・チェックが成功した場合のバージョン内に残った
配列レンジ・チェックの結果をフラグに格納するコード
を生成し（ステップ６１０：図７）、当該残った配列レ
ンジ・チェックに割り当てられたフラグを検査し且つ当
該フラグが配列レンジ・チェック成功を示している場合
には当該残った配列レンジ・チェックを無効化するコー
ドを生成する（ステップ６２０）。生成されたコードは
記憶装置に格納される。これにより、表１９の（１）の
ようなコードが生成されるようになる。

【００８２】もうひとつの方法は結果は同じであるが、
バージョニングを行うループ内のいずれの実行経路を通
過したとしても必ず行われる配列アクセスに対する配列
レンジ・チェックに限定せずに配列レンジ・チェックを
収集してＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］を計算し（ステッ
プ６６０：図８）、ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］−ＶＥ
ＲＳＩＯＮ＿ＡＮＤ［Ｂ］をフラグに割り当てる（ステ
ップ６７０）。そして、割り当てに従って配列レンジ・
チェックの結果をフラグに格納するコードを生成する
（ステップ６８０）。フラグを検査し且つ当該フラグが
配列レンジ・チェック成功を示している場合にはフラグ
に割り当てられた配列レンジ・チェックを無効化するコ
ードを生成する（ステップ６９０）。ＶＥＲＳＩＯＮ＿
ＯＲ［Ｂ］及び生成されたコードは記憶装置に格納され
る。

【００８３】また、ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］を用い
て３バージョンに分けることも可能である。この場合に
は、以下のような処理を行う（図９）。まず、ＶＥＲＳ
ＩＯＮ＿ＯＲ［Ｂ］を求め且つ記憶装置に格納する（ス
テップ７１０）。そして、ＶＥＳＩＯＮ＿ＯＲ［Ｂ］−
ＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］を求め、これにより第２
のバージョニング・ヘッダを生成し且つ記憶装置に格納
する（ステップ７２０）。この第２のバージョニング・
ヘッダによる配列レンジ・チェックが成功した場合に実
行するバージョンを生成し且つ記憶装置に格納する（ス
テップ７３０）。但し、ＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］を
用いて配列レンジ・チェックの除去を行う。これはステ
ップ５４０（図６）におけるＶＥＲＳＩＯＮ＿ＡＮＤ
［Ｂ］をＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］にして実施する。
このようなコードを生成し、以下のようにまとめる。な
お、本処理はＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］がφでな
く、且つＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］とＶＥＲＳＩＯ
Ｎ＿ＯＲ［Ｂ］が同じでない場合に機能する。

【表２０】 ＜ VERSION_AND[B] を使ったバージョニング・ヘッダ ＞ ---(1) ＜ (1)が成功したとき ＞ ＜ (VERSION_OR[B] - VERSION_AND[B]) を使った バージョニング・ヘッダ ＞ --- (2) ＜ (2) が成功した場合のバージョン。 但し、VERSION_OR[B] を基にして配列レンジ・チェック除去。 ＞---(3) ＜ (2) が失敗した場合のバージョン。 但し、VERSION_AND[B] を基にして配列レンジ・チェック除去。 ＞---(4) ＜ (1)が失敗した場合のバージョン。 但し、VERSION_AND[B]がφとして配列レンジ・チェック除去。 ＞---(5)

【００８４】このように、図９では表２０の（２）及び
（３）を求める。残りの部分は、図６で求められている
ので、表２０のようになるように全体をまとめる必要は
ある。

【００８５】表１８を図６及び図９で処理すると、以下
のようになる。

【表２１】 total = 0; if (s <= n-1 && s >= lb(a) && n-1 <= ub(a) && k >= lb(c) && k <= ub(c) && s >= lb(b) && n-1 <= ub(b)) { /* VERSION_OR[B]-VERSION_AND[B]によるヘッダ */ if (s-2 >= lb(a)){ /* VERSION_OR[B]に基づく除去によるバージョン */ for (i = s; i < n; i++){ if (a[i] == 0) { a[i] = a[i-1] + a[i-2]; } total += a[i] + c[k]; b[i] = total; } } else { /* VERSION_AND[B]に基づく除去によるバージョン */ for (i = s; i < n; i++){ if (a[i] == 0) { check(i-2 >= lb(a)); a[i] = a[i-1] + a[i-2]; } total += a[i] + c[k]; b[i] = total; } } } else { for (i = s; i < n; i++){ check(i >= lb(a)); check(i <= ub(a)); if (a[i] == 0) { check(i-2 >= lb(a)); a[i] = a[i-1] + a[i-2]; } check(k >= lb(c)); check(k <= ub(c)); total += a[i] + c[k]; check(i >= lb(b)); check(i <= ub(b)); b[i] = total; } }

【００８６】表２１を見ればすぐに分かるが、コード・
サイズがほぼ３倍になってしまう。よって、このように
３バージョンにするためには、ループ内の処理の内容が
簡単なものでなければならない。

【００８７】本処理Ｃ．はさらにバージョニングを実施
しないような場合に、処理Ａ．と組み合わせて実施する
ことができる。その処理を図１０を用いて説明する。先
に説明したＶＥＲＳＩＯＮ＿ＯＲ［Ｂ］及びＶＥＲＳＩ
ＯＮ＿ＡＮＤ［Ｂ］を求め且つ記憶装置に格納する（ス
テップ８１０）。そして、ＶＥＲＳＩＯＮ＿ＡＮＤ
［Ｂ］に１つのフラグを割り当て、ＶＥＲＳＩＯＮ＿Ｏ
Ｒ［Ｂ］−ＶＥＲＳＩＯＮ＿ＡＮＤ［Ｂ］に図２のステ
ップ１２０の処理で１又は複数のフラグを割り当てる
（ステップ８２０）。以上の割り当てに従って、各フラ
グに割り当ての配列レンジ・チェックの結果を格納する
コードを生成し且つ記憶装置に格納する（ステップ８３
０）。そして、不要な配列レンジ・チェックを除去する
処理を図２のステップ１６０に従って行う（ステップ８
４０）。これによって、バージョニングを行わない場合
でも処理を高速化することができる。

【００８８】表１８に図１０の処理を実施すると、以下
のようになる。

【表２２】

【００８９】なお、上ではループのバージョニングを説
明したが、ループでない部分についても処理Ｃ．を適用
することもできる。

【００９０】

【効果】より配列レンジ・チェックの回数を減らし、実
行速度を上げることができた。

【００９１】また、複数の配列レンジ・チェックをまと
めた広い配列レンジ・チェックを行い、この広い配列レ
ンジ・チェックが失敗した場合に厳密な配列レンジ・チ
ェックを行うという２段階のチェックを行うことにより
実行時の配列レンジ・チェックの回数を減らし、高速な
実行を可能にする方法を提供することもできた。

【００９２】さらに、ループ内のどの実行経路を通って
も必ずアクセスされる配列アクセス情報を用いてバージ
ョニングを実施する方法を提供することもできた。

【００９３】Ａｐｐｅｎｄｉｘ Ａ backward(C_OUT_OR[B], B)は以下のような擬似コードに
て求められる。

【表２３】 backward(C_OUT_OR[B], B){ T = 0; for (各配列レンジ・チェック C ∈ C_OUT_OR[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_OR[B], B)の最終的な出力
はＴである。backward(C_OUT_OR[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）、その配列レンジ・チェッ
クをＴに入れない。

【００９９】Ａｐｐｅｎｄｉｘ Ｂ forward(FLAG_IN[B], B)は以下のような擬似コードにて
求められる。

【表２４】 forward(FLAG_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(FLAG_IN[B], B)の最終的な出力は
Ｔである。forward(FLAG_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）には、その配列レンジ・
チェックをＴには入れない。

【０１０５】Ａｐｐｅｎｄｉｘ Ｃ 配列レンジ・チェックの最適化処理を以下に説明する。
概要を図１１に示す。まず、各ベーシック・ブロック内
において、実行とは逆順に、所定の条件に従ってＣ＿Ｇ
ＥＮ［Ｂ］を収集する（ステップ２１０）。収集結果
は、記憶装置に記憶される。そして、プログラムにおけ
るデータ・フロー解析の順番で、処理中のベーシック・
ブロック中に副作用を生じるような命令が含まれている
か否かの情報を用い且つ第２の条件に従ってＣ＿ＧＥＮ
［Ｂ］を伝搬させ、各ベーシック・ブロックにおけるＣ
＿ＯＵＴ［Ｂ］を生成する（ステップ２２０）。Ｃ＿Ｏ
ＵＴ［Ｂ］は記憶装置に記憶される。第２の条件に関連
して上で用いた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] 一方、Ｂが終端のベーシック・ブロックである場合に
は、 なお、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になら
ないので、このＣにて配列レンジ・チェックのためのコ
ードを生成する。但し、ここでＣについて配列レンジ・
チェックのためのコードを生成するので、以降同じ範囲
の配列レンジ・チェックを行わないようにするため、Ｃ
をＣ＿ＯＵＴ［Ｂ］に加える。

【０１１１】以上のようにして配列レンジ・チェックが
最適化される。表２４の例に本発明の最適化処理を施し
た例を以下に示しておく。図１３に表２７のフローグラ
フを示しておく。

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

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

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

【０１１４】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);

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

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

【表２９】 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)である。これを図１５にまと
めておく。

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

【表３０】 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)参考文献 特開2000−47879（ＪＰ，Ａ) 特開 平２−148330（ＪＰ，Ａ) 特開 平10−275087（ＪＰ，Ａ) 特許3280332（ＪＰ，Ｂ２) Ｍｉｄｋｉｆｆ，Ｓ．Ｐ．，ｅｔ．ａ ｌ．，”Ｏｐｔｉｍｉｚｉｎｇ ａｒｒ ａｙ ｒｅｄｅｒｅｎｃｅ ｃｈｅｃｋ ｉｎｇ ｉｎ Ｊａｖａ Ｐｒｏｇｒａ ｍｓ”，ＩＢＭ ＳＹＳＴＥＭＳ ＪＯ ＵＲＮＡＬ，1998年，Ｖｏｌ．37，Ｎ ｏ．３，ｐｐ．409−453 Ｗｅｉ−Ｎｇａｎ Ｃｈｉｎ ａｎｄ Ｅａｋ−Ｋｈｏｏｎ Ｇｏｈ，”Ａ Ｒｅｅｘａｍｉｎａｔｉｏｎ ｏｆ " Ｏｐｔｉｍｉｚａｔｉｏｎ ｏｆ Ａｒ ｒａｙ Ｓｕｂｓｃｒｉｐｔ Ｒａｎｇ ｅ Ｃｈｅｃｋｓ””，ＡＣＭ Ｔｒａ ｎｓａｃｔｉｏｎｓ ｏｎ Ｐｒｏｇｒ ａｍｍｉｎｇ Ｌａｎｇｕａｇｅ ａｎ ｄ Ｓｙｓｔｅｍｓ（ＴＯＰＬＡＳ）, 1995年，Ｖｏｌ．17，Ｎｏ．２，ｐｐ. 217−227 Ａｓｕｒｕ，Ｊ．Ｍ．，”Ｏｐｔｉｍ ｉｚａｔｉｏｎ ｏｆ Ａｒｒａｙ Ｓ ｕｂｓｃｒｉｐｔ Ｒａｎｇｅ Ｃｈｅ ｃｋｓ”，ＡＣＭ Ｌｅｔｔｅｒｓ ｏ ｎ Ｐｒｏｇｒａｍｍｉｎｇ ｌａｎｇ ｕａｇｅｓ ａｎｄ Ｓｙａｔｅｍｓ （ＬＯＰＬＡＳ），1992年，Ｖｏｌ. １，Ｎｏ．２，ｐｐ．109−118 Ａｌｉ−Ｒｅｚａ Ａｄｌ−Ｔａｂａ ｔａｂａｉ，ｅｔ．ａｌ．，”Ｆａｓ ｔ，Ｅｆｆｅｃｔｉｖｅ Ｃｏｄｅ Ｇ ｅｎｅｒａｔｉｏｎ ｉｎ ａ Ｊｕｓ ｔ−Ｉｎ−Ｔｉｍｅ Ｊａｖａ Ｃｏｍ ｐｉｌｅｒ”，ＡＣＭ ＳＩＧＰＬＡＮ Ｎｏｔｉｃｅｓ，1998年，Ｖｏｌ. 33，Ｎｏ．５，ｐｐ．280−290 Ｋｏｌｔｅ，Ｐ．，ｅｔ．ａｌ．，" Ｅｌｉｍｉｎａｔｉｏｎ ｏｆ ｒｅｄ ｕｎｄａｎｔ ａｒｒａｙ ｓｕｂｓｃ ｒｉｐｔ ｒａｎｇｅ ｃｈｅｃｋ ｓ”，ＡＣＭ ＳＩＧＰＬＡＮ Ｎｏｔ ｉｃｅｓ，1995年，Ｖｏｌ．30，Ｎｏ. ６，ｐｐ．270−278 Ｇｕｐｔａ，Ｒ．，”Ｏｐｔｉｍｉｚ ｉｎｇ ａｒｒａｙ ｂｏｕｎｄ Ｃｈ ｅｃｋｓ ｕｓｉｎｇ ｆｌｏｗ ａｎ ａｌｙｓｉｓ”，ＡＣＭ Ｌｅｔｔｅｒ ｓ ｏｎ Ｐｒｏｇｒａｍｍｉｎｇ Ｌ ａｎｇｕａｇｅｓ ａｎｄ Ｓｙａｔｅ ｍｓ（ＬＯＰＬＡＳ），1993年，Ｖｏ ｌ．２，Ｎｏ．１−４，ｐｐ．135−150 Ｇｕｐｔａ，Ｒ．，”Ａ ｆｒｅｓｈ ｌｏｏｋ ａｔ ｏｐｔｉｍｉｚｉｎ ｇ ａｒｒａｙ ｂｏｕｎｄ ｃｈｅｃ ｋｉｎｇ”，ＡＣＭ ＳＩＧＰＬＡＮ Ｎｏｔｉｃｅｓ，1990年，Ｖｏｌ．25, Ｎｏ．６，ｐｐ．272−282 (58)調査した分野(Int.Cl.⁷，ＤＢ名) G06F 9/45 G06F 9/06 G06F 12/00 - 12/06 G06F 9/30 - 9/36 ＪＳＴファイル（ＪＯＩＳ) ＣＳＤＢ（日本国特許庁) ＷＰＩ／Ｌ（ＤＩＡＬＯＧ) ＩＮＳＰＥＣ（ＤＩＡＬＯＧ)

Claims (14)

(57)【特許請求の範囲】
1. 【請求項１】プログラム内の配列アクセスに対する配列
   レンジ・チェックのためのコードを生成する方法であっ
   て、 複数の配列アクセスに対応する複数の配列レンジ・チェ
   ックを統合した統合配列レンジ・チェックの結果を記憶
   領域に格納する第１コードを生成し且つ記憶装置に記憶
   する第１ステップと、 前記記憶領域を検査し且つ当該記憶領域が前記統合配列
   レンジ・チェックの成功を示している場合には前記複数
   の配列レンジ・チェックに包含される配列レンジ・チェ
   ックのための第２コードを無効化する第３コードを生成
   し且つ記憶装置に格納する第２ステップと、 を含む配列レンジ・チェックのためのコード生成方法。
2. 【請求項２】バージョニングを実施する場合、 当該バージョニングの条件である前記統合配列レンジ・
   チェックの結果を格納した記憶領域を参照し且つ前記記
   憶領域が前記バージョニングの条件である前記統合配列
   レンジ・チェックの成功を示している場合には前記バー
   ジョニングの条件である前記統合配列レンジ・チェック
   に包含される配列レンジ・チェックのためのコードを含
   まないバージョンに分岐させ且つ前記記憶領域が前記バ
   ージョニングの条件である前記統合配列レンジ・チェッ
   クの不成功を示している場合には前記第２及び第３コー
   ドを含むバージョンに分岐するコードを生成し且つ記憶
   装置に格納するステップと、 をさらに含む請求項１記載の配列レンジ・チェックのた
   めのコード生成方法。
3. 【請求項３】前記記憶領域が、プロセッサのフラグであ
   ることを特徴とする請求項１記載の配列レンジ・チェッ
   クのためのコード生成方法。
4. 【請求項４】プログラム内のループのバージョニングを
   実行する方法であって、 前記ループ内のいずれの実行経路を通過したとしても必
   ず行われる配列アクセスに対する配列レンジ・チェック
   の第１集合情報を収集し、収集結果を記憶装置に格納す
   るステップと、 前記収集結果を用いて、バージョニングのための検査コ
   ードを生成し且つ記憶装置に格納するステップと、 前記収集結果を用いて不要な配列レンジ・チェックを除
   去し、除去不可能な配列レンジ・チェックのためのコー
   ドを含む、前記検査コードによる配列レンジ・チェック
   が成功した場合におけるバージョンを生成し且つ記憶装
   置に格納するステップと、 前記検査コードによる配列レンジ・チェックが不成功の
   場合におけるバージョンを生成し且つ記憶装置に格納す
   るステップと、 を含むバージョニング実行方法。
5. 【請求項５】前記ループ内のいずれの実行経路を通過し
   たとしても必ず行われる配列アクセスに対する配列レン
   ジ・チェックに限定せずに配列レンジ・チェックの第２
   集合情報を収集し、第２の収集結果を記憶装置に格納す
   るステップと、 前記第２集合情報から前記第１集合情報に含まれる配列
   レンジ・チェックを除去した第３集合情報を用いて、前
   記検査コードによる配列レンジ・チェックが成功した場
   合におけるバージョンのさらなるバージョニングのため
   の第２検査コードを生成し且つ記憶装置に格納するステ
   ップと、 前記第２の収集結果を用いて不要な配列レンジ・チェッ
   クを除去し、除去不可能な配列レンジ・チェックのため
   のコードを含む、前記第２検査コードによる配列レンジ
   ・チェックが成功した場合におけるバージョンを生成し
   且つ記憶装置に格納するステップと、 をさらに含み、 前記第２検査コードによる配列レンジ・チェックが不成
   功であった場合には、前記検査コードによる配列レンジ
   ・チェックが成功した場合におけるバージョンのコード
   を実行する、 請求項４記載のバージョニング実行方法。
6. 【請求項６】前記除去不可能な配列レンジ・チェックと
   インデックス変数の範囲とによる第１配列レンジ・チェ
   ックの結果を、生成されたコードを実行するプロセッサ
   のフラグに格納するためのコードを生成し且つ記憶装置
   に格納するステップと、 前記フラグを検査し且つ当該フラグが前記第１配列レン
   ジ・チェックの成功を示している場合には前記除去不可
   能な配列レンジ・チェックのためのコードを無効化する
   他のコードを生成し且つ記憶装置に格納するステップ
   と、 をさらに含む請求項４記載のバージョニング実行方法。
7. 【請求項７】前記ループ内のいずれの実行経路を通過し
   たとしても必ず行われる配列アクセスに対する配列レン
   ジ・チェックに限定せずに配列レンジ・チェックの第２
   集合情報を収集し、第２の収集結果を記憶装置に格納す
   るステップと、 前記第２集合情報から前記第１集合情報に含まれる配列
   レンジ・チェックを除去した第３集合情報の結果を、生
   成されたコードを実行するプロセッサのフラグに格納す
   るためのコードを生成し且つ記憶装置に格納するステッ
   プと、 前記フラグを検査し且つ当該フラグが前記第３集合情報
   に含まれる配列レンジ・チェックが成功したことを示し
   ている場合には前記除去不可能な配列レンジ・チェック
   のためのコードを無効化する他のコードを生成し且つ記
   憶装置に格納するステップと、 をさらに含む請求項４記載のバージョニング実行方法。
8. 【請求項８】前記第１ステップが、 前記プログラムのある部分のいずれの実行経路を通過し
   たとしても必ず行われる配列アクセスに対する配列レン
   ジ・チェックの第１集合情報を収集し、収集結果を格納
   する領域を記憶装置内に割り当てるステップと、 前記ある部分のいずれの実行経路を通過したとしても必
   ず行われる配列アクセスに対する配列レンジ・チェック
   に限定せずに配列レンジ・チェックの第２集合情報を収
   集し、第２の収集結果を格納する領域を記憶装置内に割
   り当てるステップと、 前記第２集合情報に含まれる配列レンジ・チェックの結
   果を１つの記憶領域に割り当て、前記第２集合情報から
   前記第１集合情報に含まれる配列レンジ・チェックを除
   去した第３集合情報の配列レンジ・チェックの結果を１
   又は複数の記憶領域に割り当てるステップと、 を含む請求項１記載の配列レンジ・チェックのためのコ
   ード生成方法。
9. 【請求項９】プログラム内の配列アクセスに対する配列
   レンジ・チェックのためのコードを生成する装置であっ
   て、 記憶装置と、 プロセッサにより使用可能な記憶領域と、 複数の配列アクセスに対応する複数の配列レンジ・チェ
   ックを統合した統合配列レンジ・チェックの結果を記憶
   領域に格納する第１コードを生成し且つ前記記憶装置に
   記憶する第１手段と、 前記記憶領域を検査し且つ当該記憶領域が前記統合配列
   レンジ・チェックの成功を示している場合には前記複数
   の配列レンジ・チェックに包含される配列レンジ・チェ
   ックのための第２コードを無効化する第３コードを生成
   し且つ前記記憶装置に格納する第２手段と、 を有する配列レンジ・チェックのためのコード生成装
   置。
10. 【請求項１０】プログラム内のループのバージョニング
    を実行する装置であって、 記憶装置と、 前記ループ内のいずれの実行経路を通過したとしても必
    ず行われる配列アクセスに対する配列レンジ・チェック
    の第１集合情報を収集し、収集結果を前記記憶装置に格
    納する手段と、 前記収集結果を用いて、バージョニングのための検査コ
    ードを生成し且つ前記記憶装置に格納する手段と、 前記収集結果を用いて不要な配列レンジ・チェックを除
    去し、除去不可能な配列レンジ・チェックのためのコー
    ドを含む、前記検査コードによる配列レンジ・チェック
    が成功した場合におけるバージョンを生成し且つ前記記
    憶装置に格納する手段と、 前記検査コードによる配列レンジ・チェックが不成功の
    場合におけるバージョンを生成し且つ前記記憶装置に格
    納する手段と、 を有するバージョニング実行装置。
11. 【請求項１１】処理対象プログラム内の配列アクセスに
    対する配列レンジ・チェックのためのコードを生成する
    ためのプログラムを格納した記憶媒体であって、 前記プログラムは、プロセッサに、 複数の配列アクセスに対応する複数の配列レンジ・チェ
    ックを統合した統合配列レンジ・チェックの結果を記憶
    領域に格納する第１コードを生成し且つ記憶装置に記憶
    する第１ステップと、 前記記憶領域を検査し且つ当該記憶領域が前記統合配列
    レンジ・チェックの成功を示している場合には前記複数
    の配列レンジ・チェックに包含される配列レンジ・チェ
    ックのための第２コードを無効化する第３コードを生成
    し且つ記憶装置に格納する第２ステップと、 を実行させる、記憶媒体。
12. 【請求項１２】処理対象プログラム内のループのバージ
    ョニングを実行するためのプログラムを格納した記憶媒
    体であって、 前記プログラムは、コンピュータに、 前記ループ内のいずれの実行経路を通過したとしても必
    ず行われる配列アクセスに対する配列レンジ・チェック
    の第１集合情報を収集し、収集結果を記憶装置に格納す
    るステップと、 前記収集結果を用いて、バージョニングのための検査コ
    ードを生成し且つ記憶装置に格納するステップと、 前記収集結果を用いて不要な配列レンジ・チェックを除
    去し、除去不可能な配列レンジ・チェックのためのコー
    ドを含む、前記検査コードによる配列レンジ・チェック
    が成功した場合におけるバージョンを生成し且つ記憶装
    置に格納するステップと、 前記検査コードによる配列レンジ・チェックが不成功の
    場合におけるバージョンを生成し且つ記憶装置に格納す
    るステップと、 を実行させる、記憶媒体。
13. 【請求項１３】複数の配列レンジ・チェックを統合し
    て、統合された配列レンジ・チェックのためのコードを
    生成し、記憶装置に格納するステップと、 前記統合された配列レンジ・チェックの結果が失敗であ
    った場合のために、前記複数の配列レンジ・チェックに
    含まれる配列レンジ・チェックのためのコードを生成
    し、記憶装置に格納するステップと、 を含む配列レンジ・チェックのためのコード生成方法。
14. 【請求項１４】プログラム内のある部分のバージョニン
    グを実行する方法であって、 前記ある部分内のいずれの実行経路を通過したとしても
    必ず行われる配列アクセスに対する配列レンジ・チェッ
    クの第１集合情報を収集し、収集結果を記憶装置に格納
    するステップと、 前記収集結果を用いて、バージョニングのための検査コ
    ードを生成し且つ記憶装置に格納するステップと、 前記収集結果を用いて不要な配列レンジ・チェックを除
    去し、除去不可能な配列レンジ・チェックのためのコー
    ドを含む、前記検査コードによる配列レンジ・チェック
    が成功した場合におけるバージョンを生成し且つ記憶装
    置に格納するステップと、 前記検査コードによる配列レンジ・チェックが不成功の
    場合におけるバージョンを生成し且つ記憶装置に格納す
    るステップと、 を含むバージョニング実行方法。