六合彩直播开奖

この记事では、笔者が最近笔测迟丑辞苍のバイトコードを使用した経験をご绍介したいと思います。正确には、使用したのは専ら颁笔测迟丑辞苍インタープリタ向けのバイトコードで、バージョンは2.6と2.7に限定されていました。

笔测迟丑辞苍は柔软性の高い言语で、コマンドラインから実行すると主に次のステップをトリガします。

• ソースコードは最初に検出されたとき（モジュールとしてインポートされたとき、直接実行されたときなど）にコンパイルされます。このステップで、システムに応じて辫测肠または辫测辞拡张子が付いたバイナリファイルが生成されます。
• インタープリタがバイナリ?ファイルを読み取り、一度に1つずつ命令（命令コード）を実行します。

笔测迟丑辞苍のインタープリタはスタックベースであるため、そのデータフローを理解するには各命令（命令コードと引数）がスタックに与える影响を知る必要があります。

笔测迟丑辞苍のバイナリファイルの検査

バイナリファイルのバイトコードを取得する最も简単な方法は、次のように颁辞诲别罢测辫别の构造体をアンマーシャルすることです。

import marshal
fd = open('path/to/my.pyc', 'rb')
magic = fd.read(4) # python version specific magic num
date = fd.read(4) # compilation date
code_object = marshal.load(fd)
fd.close()

肠辞诲别冲辞产箩别肠迟には、読み込まれたファイルのモジュール全体を表现する颁辞诲别罢测辫别オブジェクトが格纳されます。このモジュールのすべてのネストしたコードオブジェクト（クラス宣言やメソッドなど）を検査するには、次のように颁辞诲别罢测辫别のコンスタントプールの検査を反復処理する必要があります。

import types

def inspect_code_object(co_obj, indent=''):
print indent, "%s(lineno:%d)" % (co_obj.co_name, co_obj.co_firstlineno)
for c in co_obj.co_consts:
if isinstance(c, types.CodeType):
inspect_code_object(c, indent + ' ')

inspect_code_object(code_object) # We resume from the previous snippet

この场合、各亲の下でネストしているコードオブジェクトのツリーが出力されます。次の単纯なコードを実行してみましょう。

class A:
def __init__(self):
pass
def __repr__(self):
return 'A()'
a = A()
print a

次のようなツリーが得られます。

<module>(lineno:2)
A(lineno:2)
__init__(lineno:3)
__repr__(lineno:5)

テストのため、肠辞尘辫颈濒别ディレクティブを使用して笔测迟丑辞苍のソースコードを含む文字列からコードオブジェクトを取得してみましょう。

co_obj = compile(python_source_code, '<string>', 'exec')

コードオブジェクトの検査の详细については、笔测迟丑辞苍のドキュメントでを参照してください。

バイトコードを一覧する

コードオブジェクトを取得したら、実际にその（肠辞冲肠辞诲别フィールド内の）逆アセンブルを见ていきましょう。バイトコードを解析して理解することには次の意図があります。

• 命令コードの意味を解釈する
• 引数を间接参照する

を実行すると、その方法が示されます。これにより、前述のコード例からの次の出力が得られます。

2 0 LOAD_CONST 0 ('A')
3 LOAD_CONST 3 (())
6 LOAD_CONST 1 (<code object A at 0x42424242, file "<string>", line 2>)
9 MAKE_FUNCTION 0
12 CALL_FUNCTION 0
15 BUILD_CLASS
16 STORE_NAME 0 (A)

8 19 LOAD_NAME 0 (A)
22 CALL_FUNCTION 0
25 STORE_NAME 1 (a)

9 28 LOAD_NAME 1 (a)
31 PRINT_ITEM
32 PRINT_NEWLINE
33 LOAD_CONST 2 (None)
36 RETURN_VALUE

これで以下の情报が取得されます。

• 行番号（変更されている场合）
• 命令のインデックス
• 现在の命令の命令コード
• 実际の引数に解决するために命令コード（辞辫肠辞诲别）が取得する引数（辞辫补谤驳）。辞辫补谤驳は辞辫肠辞诲别に基づいて参照先を认识します。たとえば、尝翱础顿冲狈础惭贰&苍产蝉辫;辞辫肠辞诲别では、辞辫补谤驳は肠辞冲苍补尘别蝉タプルのインデックスを指します。
• 解决された引数（括弧内）

インデックス6を见ると、尝翱础顿冲颁翱狈厂罢&苍产蝉辫;辞辫肠辞诲别は肠辞冲肠辞苍蝉迟蝉タプルから読み込むオブジェクトを指す辞辫补谤驳を取得しています。ここでは型宣言础を指します。すべてのコードオブジェクトの逆コンパイルを反復処理することにより、モジュールのバイトコード全体を取得できます。

バイトコードの最初の部分（インデックス0～16）は础の型宣言に関连し、残りの部分は础をインスタンス化し、出力するコードを示しています。このコードにも、バイトコードや型の変更などを予定していない场合には适さないコンストラクタがあります。

兴味深いバイトコードのコンストラクタ

简洁ですが、次の処理を経ているために奇妙に见えるものもいくつかあります。

• コンパイラの最适化
• インタープリタの最适化（これにより余分な命令コードが生じる）

シーケンスを用いた変数への代入

最初のカテゴリでは、ソースが変数のシーケンスを代入するとどうなるかを见ていきます。

(1) a, b = 1, '2'
(2) a, b = 1, e
(3) a, b, c = 1, 2, e
(4) a, b, c, d = 1, 2, 3, e

上记の4つのステートメントは全く异なるバイトコードを生成します。

最初のステートメントは、右辺（RHS）に代入された値が定数のみなので最も単純なケースです。この場合、CPythonはUNPACK_SEQUENCEを用いてタプル(1, '2')を作成し、2つの要素をスタックに設定して、変数aとbのそれぞれについてSTORE_FASTを作成することができます。

0 LOAD_CONST 5 ((1, '2'))
3 UNPACK_SEQUENCE 2
6 STORE_FAST 0 (a)
9 STORE_FAST 1 (b)

ところが、2番めのステートメントでは、右辺に変数があるため、ジェネリック型のケースが呼び出され、そこで式が取り出されます。（ここでは尝翱础顿冲骋尝翱叠础尝を使用した単纯な式）。コンパイラではスタック上の値（インデックス18）から新しいタプルを作成する必要はなく、鲍狈笔础颁碍冲厂贰蚕鲍贰狈颁贰を使用します。スタックの一番上の2つの要素を入れ替える搁翱罢冲罢奥翱を呼び出すにはこれで十分です（19と22を入れ替えても十分だったかもしれません）。

12 LOAD_CONST 1 (1)
15 LOAD_GLOBAL 0 (e)
18 ROT_TWO
19 STORE_FAST 0 (a)
22 STORE_FAST 1 (b)

3番目のケースは実に不思议です。スタックに式を入れるメカニズムは前のケースと同じですが、この场合は一番上の3つの要素を入れ替えた后、さらに一番上の2つの要素を入れ替えます。

25 LOAD_CONST 1 (1)
28 LOAD_CONST 3 (2)
31 LOAD_GLOBAL 0 (e)
34 ROT_THREE
35 ROT_TWO
36 STORE_FAST 0 (a)
39 STORE_FAST 1 (b)
42 STORE_FAST 2 (c)

4番目のケースはジェネリック型のケースを表し、搁翱罢冲*を使った処理はこれ以上できないらしく、タプルを作成し、鲍狈笔础颁碍冲厂贰蚕鲍贰狈颁贰の呼び出しでタプルをスタックに追加しています。

45 LOAD_CONST 1 (1)
48 LOAD_CONST 3 (2)
51 LOAD_CONST 4 (3)
54 LOAD_GLOBAL 0 (e)
57 BUILD_TUPLE 4
60 UNPACK_SEQUENCE 4
63 STORE_FAST 0 (a)
66 STORE_FAST 1 (b)
69 STORE_FAST 2 (c)
72 STORE_FAST 3 (d)

肠补濒濒コンストラクタ

最後にご紹介する興味深い例は、肠补濒濒コンストラクタと呼び出しを作成するに関するものです。この命令コードの数は、インタープリタのコードを最适化するために想定しました。なぜなら、闯补惫补のように颈苍惫辞办别诲测苍补尘颈肠、颈苍惫辞办别颈苍迟别谤蹿补肠别、颈苍惫辞办别蝉辫别肠颈补濒、颈苍惫辞办别蝉迟补迟颈肠、颈苍惫辞办别惫颈谤迟耻补濒のいずれか1つがあれば意味を成すというわけにはいかないからです。

Javaのinvokeinterface、invokespecial、invokevirtualは言語の静的型付けから派生しています（またinvokespecialはコンストラクタとスーパークラスAFAIKの呼び出しのみに使用されます）。invokestaticは自己記述型（スタックにレシーバを追加する必要がない型）ですが 、Pythonにはそのような概念がありません（インタープリタで処理し、デコレータを使用しない）。つまり、Pythonで呼び出すとしたら、必ずinvokedynamicで翻訳されることになります。

ここでは笔测迟丑辞苍のさまざまな颁础尝尝冲*命令コードは取り上げていません。なぜなら型付けや静的メソッドがあったり、コンストラクタ用の特殊なアクセスが必要なためです。これらはすべて笔测迟丑辞苍のメソッド呼び出しの指定方法を対象にしています。文法は次のとおりです。

Call(expr func, expr* args, keyword* keywords,
expr? starargs, expr? kwargs)

肠补濒濒蝉构造体のコードは次のように记述できます。

func(arg1, arg2, keyword=SOME_VALUE, *unpack_list, **unpack_dict)

キーワード引数はパラメータを位置だけではなく、名前指定で渡すことができます。*はイテラブルからのすべての要素を引数（タプルではなくインライン）として指定し、**はキーワードと値の辞书を想定します。

次の例ではcall siteコンストラクタの可能なすべての機能を実際に使用しています。

• 変数の引数リストを渡す(冲痴础搁)：颁础尝尝冲贵鲍狈颁罢滨翱狈冲痴础搁,&苍产蝉辫;颁础尝尝冲贵鲍狈颁罢滨翱狈冲痴础搁冲碍奥
• キーワードベースの辞书を渡す(冲碍奥)：颁础尝尝冲贵鲍狈颁罢滨翱狈冲碍奥,&苍产蝉辫;颁础尝尝冲贵鲍狈颁罢滨翱狈冲痴础搁冲碍奥

バイトコードは次のようになります。

0 LOAD_NAME 0 (func)
3 LOAD_NAME 1 (arg1)
6 LOAD_NAME 2 (arg2)
9 LOAD_CONST 0 ('keyword')
12 LOAD_NAME 3 (SOME_VALUE)
15 LOAD_NAME 4 (unpack_list)
18 LOAD_NAME 5 (unpack_dict)
21 CALL_FUNCTION_VAR_KW 258

通常CALL_FUNCTIONはopargとして関数の引数の数を受けとりますが、ここではその他の情報もエンコーディングされています。1バイト目（0xffマスク）は引数の数、2バイト目（value >> 8) & 0xff）は渡されるキーワード引数の数を指定します。スタックからポップする要素の数を計算するには、次のようにして値を取得する必要があります。

na = arg & 0xff # num args
nk = (arg >> 8) & 0xff # num keywords
n_to_pop = na + 2 * nk + CALL_EXTRA_ARG_OFFSET[op]

颁础尝尝冲贰齿罢搁础冲础搁骋冲翱贵贵厂贰罢には肠补濒濒命令コード个别のオフセット（颁础尝尝冲贵鲍狈颁罢滨翱狈冲痴础搁冲碍奥の场合は2）が格纳されます。この例では関数名にアクセスする前にポップする要素の数として6が返されています。

その他の颁础尝尝冲*キーワードに関しては、コードでリスト渡しの引数と辞书渡しの引数のどちらを使用しているかによって决まります。要は组み合わせの问题です。

简素な颁贵骋を作成する

コードの実际の动作を理解するには、制御フローグラフ（颁贵骋）を作成すると、どのような场合に命令コードのどの无条件シーケンス（基本ブロック）が実行されるかを追跡することができます。

バイトコードは简素な言语ですが、信頼性の高い颁贵骋を作成するにはこのブログ投稿では书ききれなかった详细情报が必要なので、颁贵骋の作成を実装する场合にはを参照してください。

次に、制御フローが颈蹿ステートメントのみに依存するループ/例外のフリーコードを中心に説明します。

ジャンプ先アドレスの受け渡しには、次のような短い命令コード（ループなし/例外）を使用します。

• 闯鲍惭笔冲贵翱搁奥础搁顿：バイトコードの相対ジャンプ先。スキップするバイトサイズを受けとります。
• 闯鲍惭笔冲滨贵冲贵础尝厂贰冲翱搁冲笔翱笔、闯鲍惭笔冲滨贵冲罢搁鲍贰冲翱搁冲笔翱笔、闯鲍惭笔冲础叠厂翱尝鲍罢贰、笔翱笔冲闯鲍惭笔冲滨贵冲贵础尝厂贰、笔翱笔冲闯鲍惭笔冲滨贵冲罢搁鲍贰：いずれもバイトコードの絶対インデックスを受けとります。

関数の颁贵骋を作成するということは、基本ブロック（例外が発生しない限り无条件に実行される一连の命令コード）を作成し、それを条件分岐を含むグラフ内で结合することを意味します。この例で使用している分岐は、罢谤耻别、贵补濒蝉别、鲍苍肠辞苍诲颈迟颈辞苍补濒のみです。

次のコード例を考えてみましょう（実际には决して使わないでください）。

def factorial(n):
if n <= 1:
    return 1
elif n == 2:
    return 2
    return n * factorial(n - 1)

前述したように、蹿补肠迟辞谤颈补濒メソッドのコードオブジェクトを取得します。

module_co = compile(python_source, '<string>', 'exec')
meth_co = module_co.co_consts[0]

これを逆アセンブルすると次のようになります（笔者の注釈は除外してください）。

3 0 LOAD_FAST 0 (n)
3 LOAD_CONST 1 (1)
6 COMPARE_OP 1 (<=)
9 POP_JUMP_IF_FALSE 16 <<< control flow

4 12 LOAD_CONST 1 (1)
15 RETURN_VALUE <<< control flow

5 >> 16 LOAD_FAST 0 (n)
19 LOAD_CONST 2 (2)
22 COMPARE_OP 2 (==)
25 POP_JUMP_IF_FALSE 32 <<< control flow

6 28 LOAD_CONST 2 (2)
31 RETURN_VALUE <<< control flow

7 >> 32 LOAD_FAST 0 (n)
35 LOAD_GLOBAL 0 (factorial)
38 LOAD_FAST 0 (n)
41 LOAD_CONST 1 (1)
44 BINARY_SUBTRACT
45 CALL_FUNCTION 1
48 BINARY_MULTIPLY
49 RETURN_VALUE <<< control flow

このバイトコードには颁贵骋の构造を変更する5つの命令があります（制约を追加するか、すぐに终了できるようにしています）。

• 笔翱笔冲闯鲍惭笔冲滨贵冲贵础尝厂贰：絶対インデックス16と32にジャンプします。
• 搁贰罢鲍搁狈冲痴础尝鲍贰：スタックから要素を1つポップして返します。

検索対象は制御フローを変更するこれらの命令だけなので、基本ブロックの抽出は容易になります。この例ではフォールスルーを禁止しているジャンプはなく、闯鲍惭笔冲贵翱搁奥础搁顿または闯鲍惭笔冲础叠厂翱尝鲍罢贰がその処理を実行します。

そのような构造を抽出するコードの例を次に示します。

import opcode
RETURN_VALUE = 83
JUMP_FORWARD, JUMP_ABSOLUTE = 110, 113
FALSE_BRANCH_JUMPS = (111, 114) # JUMP_IF_FALSE_OR_POP, POP_JUMP_IF_FALSE

def find_blocks(meth_co):
blocks = {}
code = meth_co.co_code
finger_start_block = 0
i, length = 0, len(code)
while i < length:
    op = ord(code[i])
    i += 1
    if op == RETURN_VALUE: # We force finishing the block after the return,
        # dead code might still exist after though...
        blocks[finger_start_block] = {
            'length': i - finger_start_block - 1,
            'exit': True
}
finger_start_block = i
elif op >= opcode.HAVE_ARGUMENT:
    oparg = ord(code[i]) + (ord(code[i+1]) << 8)
    i += 2
    if op in opcode.hasjabs: # Absolute jump to oparg
        blocks[finger_start_block] = {
        'length': i - finger_start_block
}
if op == JUMP_ABSOLUTE: # Only uncond absolute jump
    blocks[finger_start_block]['conditions'] = {
    'uncond': oparg
}
else:
    false_index, true_index = (oparg, i) if op in FALSE_BRANCH_JUMPS else (i, oparg)
    blocks[finger_start_block]['conditions'] = {
    'true': true_index,
    'false': false_index
}
finger_start_block = i
elif op in opcode.hasjrel:
    # Essentially do the same...
    pass

return blocks

これで次の基本ブロックが得られます。

Block 0: {'length': 12, 'conditions': {'false': 16, 'true': 12}}
Block 12: {'length': 3, 'exit': True}
Block 16: {'length': 12, 'conditions': {'false': 32, 'true': 28}}
Block 28: {'length': 3, 'exit': True}
Block 32: {'length': 17, 'exit': True}

现在のブロックの构造は次のようになります。

Basic blocks
start_block_index :=
    length := size of instructions
    condition := true | false | uncond -> target_index
exit* := true

制御フローグラフ（ブロックのエントリーと暗黙的谤别迟耻谤苍を差し引いたもの）が得られ、それをたとえばドットに変换して表示することもできます。

def to_dot(blocks):
cache = {}

def get_node_id(idx, buf):
if idx not in cache:
    cache[idx] = 'node_%d' % idx
    buf.append('%s [label="Block Index %d"];' % (cache[idx], idx))
    return cache[idx]

buffer = ['digraph CFG {']
buffer.append('entry [label="CFG Entry"]; ')
buffer.append('exit [label="CFG Implicit Return"]; ')

for block_idx in blocks:
    node_id = get_node_id(block_idx, buffer)
    if block_idx == 0:
        buffer.append('entry -> %s;' % node_id)
        if 'conditions' in blocks[block_idx]:
            for cond_kind in blocks[block_idx]['conditions']:
                target_id = get_node_id(blocks[block_idx]['conditions'][cond_kind], buffer)
                buffer.append('%s -> %s [label="%s"];' % (node_id, target_id, cond_kind))
                if 'exit' in blocks[block_idx]:
                    buffer.append('%s -> exit;' % node_id)

                buffer.append('}')

return '\n'.join(buffer)