PageRenderTime 44ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/bin/cleanup.py

#
Python | 160 lines | 158 code | 1 blank | 1 comment | 0 complexity | 752823297788bfd7e848b2376d25a10b MD5 | raw file
    

  1. # Cleanup bpl file produced by havoc
    2. 

  2. 

  3. usage = """
    4. 

  4. Usage: 
    5. 

  5. 

  6. python cleanup.py input.bpl output.bpl
    7. 

  7. or
    8. 

  8. python cleanup.py -d directory_name 
    9. 

  9. 

  10. The latter assumes that both the input and output 
    11. 

  11. files are directory_name\\test.bpl.
    12. 

  12. 

  13. """
    14. 

    15. 

  15. import sys, re, os, ConfigParser, getopt
    16. 

  16. from collections import deque
    17. 

  17. 

  18. inputFile = ''
    19. 

  19. outputFile = ''
    20. 

  20. 

  21. # Main - this is where everything starts
    22. 

  22. def main():
    23. 

  23.   if not len(sys.argv) == 3:
    24. 

  24.     print usage
    25. 

  25.     sys.exit()
    26. 

  26. 

  27.   if sys.argv[1] == '-d':
    28. 

  28.     inputFile = sys.argv[2] + "\\test.bpl";
    29. 

  29.     outputFile = inputFile
    30. 

  30.   else:
    31. 

  31.     inputFile = sys.argv[1]
    32. 

  32.     outputFile = sys.argv[2]
    33. 

  33. 

  34.   fin = open(inputFile, 'r')
    35. 

  35.   bpl = fin.read()
    36. 

  36.   fin.close();
    37. 

  37. 

  38.   # Do the initial processing to get rid of unnecessary stuff put in by havoc
    39. 

  39.   bpl = initialProcessing(bpl);
    40. 

  40. 

  41.   fout = open(outputFile, 'w')
    42. 

  42.   fout.write(bpl)
    43. 

  43.   fout.close()
    44. 

  44. 

  45.   sys.exit()
    46. 

  46. 

  47. # Initial processing doing a few replacementes not falling into any category...
    48. 

  48. # Most of this stuff should be done by HAVOC.
    49. 

  49. def initialProcessing(bpl):
    50. 

  50. 

  51.   p = re.compile('//TAG: alloc is always > 0.*?free ensures INT_LEQ\(old\(alloc\), alloc\);', re.DOTALL)
    52. 

  52.   bpl = p.sub('modifies alloc;', bpl)
    53. 

  53.   p = re.compile('free ensures .*;\n')
    54. 

  54.   bpl = p.sub('', bpl)
    55. 

  55. 

  56.   p = re.compile('//TAG: havoc memory locations by default[ ]*\n')
    57. 

  57.   bpl = p.sub('', bpl)
    58. 

  58.   p = re.compile('//TAG: requires .*?\n')
    59. 

  59.   bpl = p.sub('', bpl)
    60. 

  60. 

  61.   p = re.compile('requires INT_GEQ\(obj_size, 0\);\n')
    62. 

  62.   bpl = p.sub('free requires INT_GEQ(obj_size, 0);\n', bpl)
    63. 

  63. 

  64.   p = re.compile('assume LOOP_([a-zA-Z0-9_]*)_Res_.+ == Res_.+;\n')
    65. 

  65.   bpl = p.sub('', bpl)
    66. 

  66. 

  67.   p = re.compile('ensures old\(alloc\) <= alloc;\n')
    68. 

  68.   bpl = p.sub('', bpl)
    69. 

  69. 

  70.   p = re.compile('[ ]*assume[ ]+INT_LT\(.+,[ ]*alloc\)[ ]*;[ ]*\n')
    71. 

  71.   bpl = p.sub('', bpl)
    72. 

  72.   p = re.compile('/\*assert \*/ assume INT_LEQ\(.+, alloc\);\n')
    73. 

  73.   bpl = p.sub('', bpl)
    74. 

  74. 

  75.   # Removing the "name" type
    76. 

  76.   p = re.compile('type name;\n')
    77. 

  77.   bpl = p.sub('', bpl)
    78. 

  78.   p = re.compile('var Mem: \[name\]\[int\]int;\n')
    79. 

  79.   bpl = p.sub('', bpl)
    80. 

  80.   p = re.compile('function Field\(int\) returns \(name\);\n')
    81. 

  81.   bpl = p.sub('', bpl)
    82. 

  82.   p = re.compile('const unique .*:name;\n')
    83. 

  83.   bpl = p.sub('', bpl)
    84. 

  84.   p = re.compile('var LOOP_.*_Mem:\[name\]\[int\]int;\n')
    85. 

  85.   bpl = p.sub('', bpl)
    86. 

  86.   p = re.compile('LOOP_.*_Mem := Mem;\n')
    87. 

  87.   bpl = p.sub('', bpl)
    88. 

  88. 

  89.   # Get rid of all Base stuff - sometimes those blow up
    90. 

  90.   p = re.compile('function Base\(int\) returns \(int\);\n')
    91. 

  91.   bpl = p.sub('', bpl)
    92. 

  92.   p = re.compile('//axiom\(forall x: int :: {Base\(x\)} Base\(x\) <= x\);\n')
    93. 

  93.   bpl = p.sub('', bpl)
    94. 

  94.   p = re.compile('axiom\(forall x: int :: {Base\(x\)} INT_LEQ\(Base\(x\), x\)\);\n')
    95. 

  95.   bpl = p.sub('', bpl)
    96. 

  96.   p = re.compile('axiom\(forall b:int, a:int, t:name :: {MatchBase\(b, a, T.Ptr\(t\)\)} MatchBase\(b, a, T.Ptr\(t\)\) <==> Base\(a\) == b\);\n')
    97. 

  97.   bpl = p.sub('', bpl)
    98. 

  98.   p = re.compile('axiom\(forall v:int, t:name :: {HasType\(v, T.Ptr\(t\)\)} HasType\(v, T.Ptr\(t\)\) <==> \(v == 0 \|\| \(INT_GT\(v, 0\) && Match\(v, t\) && MatchBase\(Base\(v\), v, t\)\)\)\);\n')
    99. 

  99.   bpl = p.sub('', bpl)
    100. 

  100.   p = re.compile('ensures Base\(new\) == new;\n')
    101. 

  101.   bpl = p.sub('', bpl)
    102. 

  102.   p = re.compile('axiom\(Base\(.+\) == .+\);\n')
    103. 

  103.   bpl = p.sub('', bpl)
    104. 

  104.   p = re.compile('assume \(Base\(.+\) == .+\);\n')
    105. 

  105.   bpl = p.sub('', bpl)
    106. 

  106. 

  107.   p = re.compile('type byte;.*FourBytesToInt\(c0, c1, c2, c3\) ==> b0 == c0 && b1 == c1 && b2 == c2 && b3 == c3\);', re.DOTALL)
    108. 

  108.   bpl = p.sub('', bpl)
    109. 

  109. 

  110.   p = re.compile('function Equal\(\[int\]bool, \[int\]bool\) returns \(bool\);.*Unified\(M\[Field\(x\) := M\[Field\(x\)\]\[x := y\]\]\) == Unified\(M\)\[x := y\]\);', re.DOTALL)
    111. 

  111.   bpl = p.sub('', bpl)
    112. 

  112. 

  113.   p = re.compile('function Match\(a:int, t:name\) returns \(bool\);.*Field\(a\) == T.Ptr\(t\)\);', re.DOTALL)
    114. 

  114.   bpl = p.sub('', bpl)
    115. 

  115. 

  116.   p = re.compile('axiom\(forall a:int, b:int :: {BIT_BAND\(a,b\)}.*{BIT_BAND\(a,b\)} a == 0 \|\| b == 0 ==> BIT_BAND\(a,b\) == 0\);', re.DOTALL)
    117. 

  117.   bpl = p.sub('', bpl)
    118. 

  118.   p = re.compile('axiom\(forall a:int, b:int :: {DIV\(a,b\)}.*a > b \* \(DIV\(a,b\) \+ 1\)[ ]*\n[ ]*\);', re.DOTALL)
    119. 

  119.   bpl = p.sub('', bpl)
    120. 

  120.   p = re.compile('function POW2\(a:int\) returns \(bool\);.*axiom POW2\(33554432\);', re.DOTALL)
    121. 

  121.   bpl = p.sub('', bpl)
    122. 

  122.   p = re.compile('procedure nondet_choice\(\) returns \(x:int\);.*ensures x == DetChoiceFunc\(old\(detChoiceCnt\)\);', re.DOTALL)
    123. 

  123.   bpl = p.sub('', bpl)
    124. 

  124. 

  125.   p = re.compile('function .*Inv\(int\) returns \(int\);\n')
    126. 

  126.   bpl = p.sub('', bpl)
    127. 

  127.   p = re.compile('function _S_.*Inv\(\[int\]bool\) returns \(\[int\]bool\);\n')
    128. 

  128.   bpl = p.sub('', bpl)
    129. 

  129.   p = re.compile('function _S_.*\(\[int\]bool\) returns \(\[int\]bool\);\n')
    130. 

  130.   bpl = p.sub('', bpl)
    131. 

  131.   p = re.compile('axiom \(forall x:int :: {.*Inv\(.*\(x\)\)} .*Inv\(.*\(x\)\) == x\);\n')
    132. 

  132.   bpl = p.sub('', bpl)
    133. 

  133.   p = re.compile('axiom \(forall x:int :: {.*Inv\(x\)} .*\(.*Inv\(x\)\) == x\);\n')
    134. 

  134.   bpl = p.sub('', bpl)
    135. 

  135.   p = re.compile('axiom \(forall x:int, S:\[int\]bool :: {_S_.*\(S\)\[x\]} _S_.*\(S\)\[x\] <==> S\[.*Inv\(x\)\]\);\n')
    136. 

  136.   bpl = p.sub('', bpl)
    137. 

  137.   p = re.compile('axiom \(forall x:int, S:\[int\]bool :: {_S_.*Inv\(S\)\[x\]} _S_.*Inv\(S\)\[x\] <==> S\[.*\(x\)\]\);\n')
    138. 

  138.   bpl = p.sub('', bpl)
    139. 

  139.   p = re.compile('axiom \(forall x:int, S:\[int\]bool :: {S\[x\], _S_.*\(S\)} S\[x\] ==> _S_.*\(S\)\[.*\(x\)\]\);\n')
    140. 

  140.   bpl = p.sub('', bpl)
    141. 

  141.   p = re.compile('axiom \(forall x:int, S:\[int\]bool :: {_S_.*\(S\)\[x\]} _S_.*\(S\)\[x\] <==> S\[.*Inv\(x\)\]\);\n')
    142. 

  142.   bpl = p.sub('', bpl)
    143. 

  143.   p = re.compile('axiom \(forall x:int, S:\[int\]bool :: {S\[x\], _S_.*Inv\(S\)} S\[x\] ==> _S_.*Inv\(S\)\[.*Inv\(x\)\]\);\n')
    144. 

  144.   bpl = p.sub('', bpl)
    145. 

  145.   p = re.compile('//axiom \(forall x:int :: {.*Inv\(x\)} .*Inv\(x\) == x - .*\);\n')
    146. 

  146.   bpl = p.sub('', bpl)
    147. 

  147.   p = re.compile('axiom \(forall x:int :: {.*Inv\(x\)} .*Inv\(x\) == INT_SUB\(x,.+\)\);\n')
    148. 

  148.   bpl = p.sub('', bpl)
    149. 

  149.   p = re.compile('axiom \(forall x:int :: {MINUS_BOTH_PTR_OR_BOTH_INT\(x, .*, .*\)} MINUS_BOTH_PTR_OR_BOTH_INT\(x, .*, .*\) == .*Inv\(x\)\);\n')
    150. 

  150.   bpl = p.sub('', bpl)
    151. 

  151.   p = re.compile('axiom \(forall x:int :: {MINUS_LEFT_PTR\(x, .*, .*\)} MINUS_LEFT_PTR\(x, .*, .*\) == .*Inv\(x\)\);\n')
    152. 

  152.   bpl = p.sub('', bpl)
    153. 

  153.   p = re.compile('//axiom \(forall x:int :: {.+\(x\)} .+\(x\) == PLUS\(x, 1, [0-9]+\)\);\n')
    154. 

  154.   bpl = p.sub('', bpl)
    155. 

  155.   p = re.compile('axiom \(forall x:int :: {.+\(x\)} .+\(x\) == PLUS\(x, 1, [0-9]+\)\);\n')
    156. 

  156.   bpl = p.sub('', bpl)
    157. 

  157.   return bpl
    158. 

  158. 

  159. main()
    160. 

  160. 

  161.