Uncover 使用時の制限事項

注釈付きコードのみ計測可能

Uncover は 「Uncover を使用するための要件」の説明に従って準備されているコードのみを計測できます。注釈の付いていないコードは、バイナリにリンクされているアセンブリ言語コード、またはそのセクションに示されてるものより古いコンパイラまたはオペレーティングシステムでコンパイルされたモジュールから来ている場合があります。

準備から特別に除外されているのは、asm 文または .il テンプレートを含むアセンブリ言語モジュールおよび関数です。

機械命令はソースコードと異なる場合がある

Uncover は機械コード上で動作します。Uncover は機械命令のカバレージを検出し、このカバレージをソースコードと関連付けます。一部のソースコード文は関連した機械命令を持たないため、Uncover はそのような文のカバレージを報告しないと思われる場合があります。

例 1

次に示すコードの一部を考えてみましょう。

#define A 100
#define B 200
...
   if (A>B) {
        ...
   }

Uncover が if 文の 0 以外の実行数を報告することを期待しても、コンパイラはこのコードを削除する可能性があるため、Uncover は計測中にそれを表示しません。そのため、これらの命令に対してカバレージは報告されません。

例 2

次は、デッドコードの例です。

1  void foo() 
2  {
3     A();
4     return;
5     B();
6     C();
7     D();
8     return;
9   }                                                                

B、C、D の呼び出しは実行されることがないため、対応するアセンブリではこのコードが削除されています。

foo:
                        .L900000109:
/* 000000          2 */         save    %sp,-96,%sp
/* 0x0004          3 */         call    A       ! params =      ! Result = 
/* 0x0008            */         nop
/* 0x000c          8 */         ret     ! Result = 
/* 0x0010            */         restore %g0,%g0,%g0

そのため、行 5 から 6 までに対してカバレージは報告されません。

   Excl.       Excl.     Excl.  Excl.      Excl.
   Uncoverage  Function  Instr  Block      Instr
               Count     Exec   Covered %  Covered %
                                                             1.  void foo() 
## 0           1         1      100        100               2.   {
                                                                <Function: foo
## 0           0         2        0          0               3.      A();
                                                             4.      return;
                                                             5.      B();
                                                             6.      C();
                                                             7.      D();
                                                             8.     return;
## 0           0         2        0          0               9.    }
  

例 3

次は、冗長なコードの例です。

      1  int g;
      2  int foo() {
      3    int x;
      4    x = g;
      5    for (int i=0; i<100; i++)
      6        x++;
      7    return x;
      8  }

低い最適化レベルでは、コンパイラがすべての行にコードを生成する可能性があります。

foo:
                         .L900000107:
 /* 000000          3 */         save    %sp,-112,%sp
 /* 0x0004          5 */         sethi   %hi(g),%l1
 /* 0x0008            */         ld      [%l1+%lo(g)],%l3 ! volatile
 /* 0x000c            */         add     %l1,%lo(g),%l2
 /* 0x0010          6 */         st      %g0,[%fp-12]
 /* 0x0014          5 */         st      %l3,[%fp-8]
 /* 0x0018          6 */         ld      [%fp-12],%l4
 /* 0x001c            */         cmp     %l4,100
 /* 0x0020            */         bge,a,pn        %icc,.L900000105
 /* 0x0024          8 */         ld      [%fp-8],%l1
                        .L17:
 /* 0x0028          7 */         ld      [%fp-8],%l1
                         .L900000104:
 /* 0x002c          6 */         ld      [%fp-12],%l3
 /* 0x0030          7 */         add     %l1,1,%l2
 /* 0x0034            */         st      %l2,[%fp-8]
 /* 0x0038          6 */         add     %l3,1,%l4
 /* 0x003c            */         st      %l4,[%fp-12]
 /* 0x0040            */         ld      [%fp-12],%l5
 /* 0x0044            */         cmp     %l5,100
 /* 0x0048            */         bl,a,pn %icc,.L900000104
 /* 0x004c          7 */         ld      [%fp-8],%l1
 /* 0x0050          8 */         ld      [%fp-8],%l1
                         .L900000105:
 /* 0x0054          8 */         st      %l1,[%fp-4]
 /* 0x0058            */         ld      [%fp-4],%i0
 /* 0x005c            */         ret     ! Result =  %i0
 /* 0x0060            */         restore %g0,%g0,%g0

高い最適化レベルでは、実行可能なソース行のほとんどに、対応する命令がありません。

foo:
 /* 000000          5 */         sethi   %hi(g),%o5
 /* 0x0004            */         ld      [%o5+%lo(g)],%o4
 /* 0x0008          8 */         retl    ! Result =  %o0
 /* 0x000c          5 */         add     %o4,100,%o0

そのため、一部の行に対してカバレージは報告されません。

     Excl.       Excl.     Excl.  Excl.      Excl.
    Uncoverage  Function  Instr  Block      Instr
                Count     Exec   Covered %  Covered %
                                                              1. int g;
    0           0         0        0          0               2. int foo() {
                                                              <Function foo>
                                                              3.   int x;
                                                              4.   x = g;
                                                                            
                                                            Source loop below has tag L1
                                                            Induction variable substitution performed on L1
                                                            L1 deleted as dead code
 ## 0           1         3      100        100               5.   for (int i=0; i<100; i++)
                                                              6.       x++;
                                                              7.   return x;
    0           0         1        0          0               8. }