1 #!/usr/bin/python3 2 # Copyright (C) 2017 The Android Open Source Project 3 # 4 # Licensed under the Apache License, Version 2.0 (the "License"); 5 # you may not use this file except in compliance with the License. 6 # You may obtain a copy of the License at 7 # 8 # http://www.apache.org/licenses/LICENSE-2.0 9 # 10 # Unless required by applicable law or agreed to in writing, software 11 # distributed under the License is distributed on an "AS IS" BASIS, 12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 # See the License for the specific language governing permissions and 14 # limitations under the License. 15 16 # 17 # Generates the src/art/Test988Intrinsics.java file. 18 # Re-run this every time art/compiler/intrinics_list.h is modified. 19 # 20 # $> python3.4 gen_srcs.py > src/art/Test988Intrinsics.java 21 # 22 23 import argparse 24 import os 25 import re 26 import collections 27 import sys 28 29 from string import Template 30 31 # Relative path to art/compiler/intrinsics_list.h 32 INTRINSICS_LIST_H = os.path.dirname(os.path.realpath(__file__)) + "/../../compiler/intrinsics_list.h" 33 34 # Macro parameter index to V(). Negative means from the end. 35 IDX_STATIC_OR_VIRTUAL = 1 36 IDX_SIGNATURE = -1 37 IDX_METHOD_NAME = -2 38 IDX_CLASS_NAME = -3 39 40 # Exclude all hidden API. 41 KLASS_BLACK_LIST = ['sun.misc.Unsafe', 'libcore.io.Memory', 'java.lang.StringFactory'] 42 METHOD_BLACK_LIST = [('java.lang.ref.Reference', 'getReferent'), 43 ('java.lang.String', 'getCharsNoCheck'), 44 ('java.lang.System', 'arraycopy')] # arraycopy has a manual test. 45 46 # When testing a virtual function, it needs to operate on an instance. 47 # These instances will be created with the following values, 48 # otherwise a default 'new T()' is used. 49 KLASS_INSTANCE_INITIALIZERS = { 50 'java.lang.String' : '"some large string"', 51 'java.lang.StringBuffer' : 'new java.lang.StringBuffer("some large string buffer")', 52 'java.lang.StringBuilder' : 'new java.lang.StringBuilder("some large string builder")', 53 'java.lang.ref.Reference' : 'new java.lang.ref.WeakReference(new Object())' 54 }; 55 56 OUTPUT_TPL = Template(""" 57 /* 58 * Copyright (C) 2017 The Android Open Source Project 59 * 60 * Licensed under the Apache License, Version 2.0 (the "License"); 61 * you may not use this file except in compliance with the License. 62 * You may obtain a copy of the License at 63 * 64 * http://www.apache.org/licenses/LICENSE-2.0 65 * 66 * Unless required by applicable law or agreed to in writing, software 67 * distributed under the License is distributed on an "AS IS" BASIS, 68 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 69 * See the License for the specific language governing permissions and 70 * limitations under the License. 71 */ 72 73 // AUTO-GENENERATED by gen_srcs.py: DO NOT EDIT HERE DIRECTLY. 74 // 75 // $$> python3.4 gen_srcs.py > src/art/Test988Intrinsics.java 76 // 77 // RUN ABOVE COMMAND TO REGENERATE THIS FILE. 78 79 package art; 80 81 class Test988Intrinsics { 82 // Pre-initialize *all* instance variables used so that their constructors are not in the trace. 83 $static_fields 84 85 static void initialize() { 86 // Ensure all static variables are initialized. 87 // In addition, pre-load classes here so that we don't see diverging class loading traces. 88 $initialize_classes 89 } 90 91 static void test() { 92 // Call each intrinsic from art/compiler/intrinsics_list.h to make sure they are traced. 93 $test_body 94 } 95 } 96 """) 97 98 JNI_TYPES = { 99 'Z' : 'boolean', 100 'B' : 'byte', 101 'C' : 'char', 102 'S' : 'short', 103 'I' : 'int', 104 'J' : 'long', 105 'F' : 'float', 106 'D' : 'double', 107 'L' : 'object' 108 }; 109 110 debug_printing_enabled = False 111 112 def debug_print(x): 113 if debug_printing_enabled: 114 print(x, file=sys.stderr) 115 116 # Parse JNI sig into a list, e.g. "II" -> ['I', 'I'], '[[IJ' -> ['[[I', 'J'], etc. 117 def sig_to_parameter_type_list(sig): 118 sig = re.sub(r'[(](.*)[)].*', r'\1', sig) 119 120 lst = [] 121 obj = "" 122 is_obj = False 123 is_array = False 124 for x in sig: 125 if is_obj: 126 obj = obj + x 127 if x == ";": 128 is_obj = False 129 lst.append(obj) 130 obj = "" 131 elif is_array: 132 obj = obj + x 133 if x != "[": 134 is_array = False 135 lst.append(obj) 136 obj = "" 137 else: 138 if x == "[": 139 obj = "[" 140 is_array = True 141 elif x == "L": 142 obj = "L" 143 is_obj = True 144 else: 145 lst.append(x) 146 147 return lst 148 149 # Convert a single JNI descriptor into a pretty java name, e.g. "[I" -> "int[]", etc. 150 def javafy_name(kls_name): 151 if kls_name.startswith("L"): 152 kls_name = kls_name.lstrip("L").rstrip(";") 153 return kls_name.replace("/", ".") 154 elif kls_name.startswith("["): 155 array_count = kls_name.count("[") 156 non_array = javafy_name(kls_name.lstrip("[")) 157 return non_array + ("[]" * array_count) 158 159 return JNI_TYPES.get(kls_name, kls_name) 160 161 def extract_staticness(static_or_virtual): 162 if static_or_virtual == "kStatic": 163 return 'static' 164 return 'virtual' # kVirtual, kDirect 165 166 class MethodInfo: 167 def __init__(self, staticness, pretty_params, method, kls): 168 # 'virtual' or 'static' 169 self.staticness = staticness 170 # list of e.g. ['int', 'double', 'java.lang.String'] etc 171 self.parameters = pretty_params 172 # e.g. 'toString' 173 self.method_name = method 174 # e.g. 'java.lang.String' 175 self.klass = kls 176 177 def __str__(self): 178 return "MethodInfo " + str(self.__dict__) 179 180 def dummy_parameters(self): 181 dummy_values = { 182 'boolean' : 'false', 183 'byte' : '(byte)0', 184 'char' : "'x'", 185 'short' : '(short)0', 186 'int' : '0', 187 'long' : '0L', 188 'float' : '0.0f', 189 'double' : '0.0' 190 } 191 192 def object_dummy(name): 193 if name == "java.lang.String": 194 return '"hello"' 195 else: 196 return "(%s)null" %(name) 197 return [ dummy_values.get(param, object_dummy(param)) for param in self.parameters ] 198 199 def dummy_instance_value(self): 200 return KLASS_INSTANCE_INITIALIZERS.get(self.klass, 'new %s()' %(self.klass)) 201 202 def is_blacklisted(self): 203 for blk in KLASS_BLACK_LIST: 204 if self.klass.startswith(blk): 205 return True 206 207 return (self.klass, self.method_name) in METHOD_BLACK_LIST 208 209 # parse the V(...) \ list of items into a MethodInfo 210 def parse_method_info(items): 211 def get_item(idx): 212 return items[idx].strip().strip("\"") 213 214 staticness = get_item(IDX_STATIC_OR_VIRTUAL) 215 sig = get_item(IDX_SIGNATURE) 216 method = get_item(IDX_METHOD_NAME) 217 kls = get_item(IDX_CLASS_NAME) 218 219 debug_print ((sig, method, kls)) 220 221 staticness = extract_staticness(staticness) 222 kls = javafy_name(kls) 223 param_types = sig_to_parameter_type_list(sig) 224 pretty_params = param_types 225 pretty_params = [javafy_name(i) for i in param_types] 226 227 return MethodInfo(staticness, pretty_params, method, kls) 228 229 # parse a line containing ' V(...)' into a MethodInfo 230 def parse_line(line): 231 line = line.strip() 232 if not line.startswith("V("): 233 return None 234 235 line = re.sub(r'V[(](.*)[)]', r'\1', line) 236 debug_print(line) 237 238 items = line.split(",") 239 240 method_info = parse_method_info(items) 241 return method_info 242 243 # Generate all the MethodInfo that we parse from intrinsics_list.h 244 def parse_all_method_infos(): 245 with open(INTRINSICS_LIST_H) as f: 246 for line in f: 247 s = parse_line(line) 248 if s is not None: 249 yield s 250 251 # Format a receiver name. For statics, it's the class name, for receivers, it's an instance variable 252 def format_receiver_name(method_info): 253 receiver = method_info.klass 254 if method_info.staticness == 'virtual': 255 receiver = "instance_" + method_info.klass.replace(".", "_") 256 return receiver 257 258 # Format a dummy call with dummy method parameters to the requested method. 259 def format_call_to(method_info): 260 dummy_args = ", ".join(method_info.dummy_parameters()) 261 receiver = format_receiver_name(method_info) 262 263 return ("%s.%s(%s);" %(receiver, method_info.method_name, dummy_args)) 264 265 # Format a static variable with an instance that could be used as the receiver 266 # (or None for non-static methods). 267 def format_instance_variable(method_info): 268 if method_info.staticness == 'static': 269 return None 270 return "static %s %s = %s;" %(method_info.klass, format_receiver_name(method_info), method_info.dummy_instance_value()) 271 272 def format_initialize_klass(method_info): 273 return "%s.class.toString();" %(method_info.klass) 274 275 def indent_list(lst, indent): 276 return [' ' * indent + i for i in lst] 277 278 def main(): 279 global debug_printing_enabled 280 parser = argparse.ArgumentParser(description='Generate art/test/988-method-trace/src/art/Test988Intrinsics.java') 281 parser.add_argument('-d', '--debug', action='store_true', dest='debug', help='Print extra debugging information to stderr.') 282 parser.add_argument('output_file', nargs='?', metavar='<output-file>', default=sys.stdout, type=argparse.FileType('w'), help='Destination file to write to (default: stdout).') 283 args = parser.parse_args() 284 285 debug_printing_enabled = args.debug 286 287 ##### 288 289 call_str_list = [] 290 instance_variable_dict = collections.OrderedDict() 291 initialize_klass_dict = collections.OrderedDict() 292 for i in parse_all_method_infos(): 293 debug_print(i) 294 if i.is_blacklisted(): 295 debug_print("Blacklisted: " + str(i)) 296 continue 297 298 call_str = format_call_to(i) 299 debug_print(call_str) 300 301 call_str_list.append(call_str) 302 303 instance_variable = format_instance_variable(i) 304 if instance_variable is not None: 305 debug_print(instance_variable) 306 instance_variable_dict[i.klass] = instance_variable 307 308 initialize_klass_dict[i.klass] = format_initialize_klass(i) 309 310 static_fields = indent_list([ value for (key, value) in instance_variable_dict.items() ], 2) 311 test_body = indent_list(call_str_list, 4) 312 initialize_classes = indent_list([ value for (key, value) in initialize_klass_dict.items() ], 4) 313 314 print(OUTPUT_TPL.substitute(static_fields="\n".join(static_fields), 315 test_body="\n".join(test_body), 316 initialize_classes="\n".join(initialize_classes)). 317 strip("\n"), \ 318 file=args.output_file) 319 320 if __name__ == '__main__': 321 main() 322
