blob: 728074beb4e90386ae7a1dd33407da5cf10756ea [file] [log] [blame]
#!/usr/bin/python3
# Copyright (C) 2017 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Generates the src/art/Test988Intrinsics.java file.
# Re-run this every time art/compiler/intrinics_list.h is modified.
#
# $> python3.4 gen_srcs.py > src/art/Test988Intrinsics.java
#
import argparse
import os
import re
import collections
import sys
from string import Template
# Relative path to art/runtime/intrinsics_list.h
INTRINSICS_LIST_H = os.path.dirname(os.path.realpath(__file__)) + "/../../runtime/intrinsics_list.h"
# Macro parameter index to V(). Negative means from the end.
IDX_STATIC_OR_VIRTUAL = 1
IDX_SIGNATURE = -1
IDX_METHOD_NAME = -2
IDX_CLASS_NAME = -3
# Exclude all hidden API.
KLASS_BLOCK_LIST = ['sun.misc.Unsafe', 'libcore.io.Memory', 'java.lang.StringFactory',
'java.lang.invoke.MethodHandle', # invokes are tested by 956-method-handles
'java.lang.invoke.VarHandle' ] # TODO(b/65872996): will tested separately
METHOD_BLOCK_LIST = [('java.lang.ref.Reference', 'getReferent'),
('java.lang.String', 'getCharsNoCheck'),
('java.lang.System', 'arraycopy')] # arraycopy has a manual test.
# When testing a virtual function, it needs to operate on an instance.
# These instances will be created with the following values,
# otherwise a default 'new T()' is used.
KLASS_INSTANCE_INITIALIZERS = {
'java.lang.String' : '"some large string"',
'java.lang.StringBuffer' : 'new java.lang.StringBuffer("some large string buffer")',
'java.lang.StringBuilder' : 'new java.lang.StringBuilder("some large string builder")',
'java.lang.ref.Reference' : 'new java.lang.ref.WeakReference(new Object())'
};
OUTPUT_TPL = Template("""
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// AUTO-GENENERATED by gen_srcs.py: DO NOT EDIT HERE DIRECTLY.
//
// $$> python3.4 gen_srcs.py > src/art/Test988Intrinsics.java
//
// RUN ABOVE COMMAND TO REGENERATE THIS FILE.
package art;
class Test988Intrinsics {
// Pre-initialize *all* instance variables used so that their constructors are not in the trace.
$static_fields
static void initialize() {
// Ensure all static variables are initialized.
// In addition, pre-load classes here so that we don't see diverging class loading traces.
$initialize_classes
}
static void test() {
// Call each intrinsic from art/runtime/intrinsics_list.h to make sure they are traced.
$test_body
}
}
""")
JNI_TYPES = {
'Z' : 'boolean',
'B' : 'byte',
'C' : 'char',
'S' : 'short',
'I' : 'int',
'J' : 'long',
'F' : 'float',
'D' : 'double',
'L' : 'object'
};
debug_printing_enabled = False
def debug_print(x):
if debug_printing_enabled:
print(x, file=sys.stderr)
# Parse JNI sig into a list, e.g. "II" -> ['I', 'I'], '[[IJ' -> ['[[I', 'J'], etc.
def sig_to_parameter_type_list(sig):
sig = re.sub(r'[(](.*)[)].*', r'\1', sig)
lst = []
obj = ""
is_obj = False
is_array = False
for x in sig:
if is_obj:
obj = obj + x
if x == ";":
is_obj = False
lst.append(obj)
obj = ""
elif is_array:
obj = obj + x
if x != "[":
is_array = False
lst.append(obj)
obj = ""
else:
if x == "[":
obj = "["
is_array = True
elif x == "L":
obj = "L"
is_obj = True
else:
lst.append(x)
return lst
# Convert a single JNI descriptor into a pretty java name, e.g. "[I" -> "int[]", etc.
def javafy_name(kls_name):
if kls_name.startswith("L"):
kls_name = kls_name.lstrip("L").rstrip(";")
return kls_name.replace("/", ".")
elif kls_name.startswith("["):
array_count = kls_name.count("[")
non_array = javafy_name(kls_name.lstrip("["))
return non_array + ("[]" * array_count)
return JNI_TYPES.get(kls_name, kls_name)
def extract_staticness(static_or_virtual):
if static_or_virtual == "kStatic":
return 'static'
return 'virtual' # kVirtual, kDirect
class MethodInfo:
def __init__(self, staticness, pretty_params, method, kls):
# 'virtual' or 'static'
self.staticness = staticness
# list of e.g. ['int', 'double', 'java.lang.String'] etc
self.parameters = pretty_params
# e.g. 'toString'
self.method_name = method
# e.g. 'java.lang.String'
self.klass = kls
def __str__(self):
return "MethodInfo " + str(self.__dict__)
def placeholder_parameters(self):
placeholder_values = {
'boolean' : 'false',
'byte' : '(byte)0',
'char' : "'x'",
'short' : '(short)0',
'int' : '0',
'long' : '0L',
'float' : '0.0f',
'double' : '0.0'
}
def object_placeholder(name):
if name == "java.lang.String":
return '"hello"'
else:
return "(%s)null" %(name)
return [ placeholder_values.get(param, object_placeholder(param)) for param in self.parameters ]
def placeholder_instance_value(self):
return KLASS_INSTANCE_INITIALIZERS.get(self.klass, 'new %s()' %(self.klass))
def is_blocklisted(self):
for blk in KLASS_BLOCK_LIST:
if self.klass.startswith(blk):
return True
return (self.klass, self.method_name) in METHOD_BLOCK_LIST
# parse the V(...) \ list of items into a MethodInfo
def parse_method_info(items):
def get_item(idx):
return items[idx].strip().strip("\"")
staticness = get_item(IDX_STATIC_OR_VIRTUAL)
sig = get_item(IDX_SIGNATURE)
method = get_item(IDX_METHOD_NAME)
kls = get_item(IDX_CLASS_NAME)
debug_print ((sig, method, kls))
staticness = extract_staticness(staticness)
kls = javafy_name(kls)
param_types = sig_to_parameter_type_list(sig)
pretty_params = param_types
pretty_params = [javafy_name(i) for i in param_types]
return MethodInfo(staticness, pretty_params, method, kls)
# parse a line containing ' V(...)' into a MethodInfo
def parse_line(line):
line = line.strip()
if not line.startswith("V("):
return None
line = re.sub(r'V[(](.*)[)]', r'\1', line)
debug_print(line)
items = line.split(",")
method_info = parse_method_info(items)
return method_info
# Generate all the MethodInfo that we parse from intrinsics_list.h
def parse_all_method_infos():
with open(INTRINSICS_LIST_H) as f:
for line in f:
s = parse_line(line)
if s is not None:
yield s
# Format a receiver name. For statics, it's the class name, for receivers, it's an instance variable
def format_receiver_name(method_info):
receiver = method_info.klass
if method_info.staticness == 'virtual':
receiver = "instance_" + method_info.klass.replace(".", "_")
return receiver
# Format a placeholder call with placeholder method parameters to the requested method.
def format_call_to(method_info):
placeholder_args = ", ".join(method_info.placeholder_parameters())
receiver = format_receiver_name(method_info)
return ("%s.%s(%s);" %(receiver, method_info.method_name, placeholder_args))
# Format a static variable with an instance that could be used as the receiver
# (or None for non-static methods).
def format_instance_variable(method_info):
if method_info.staticness == 'static':
return None
return "static %s %s = %s;" %(method_info.klass, format_receiver_name(method_info), method_info.placeholder_instance_value())
def format_initialize_klass(method_info):
return "%s.class.toString();" %(method_info.klass)
def indent_list(lst, indent):
return [' ' * indent + i for i in lst]
def main():
global debug_printing_enabled
parser = argparse.ArgumentParser(description='Generate art/test/988-method-trace/src/art/Test988Intrinsics.java')
parser.add_argument('-d', '--debug', action='store_true', dest='debug', help='Print extra debugging information to stderr.')
parser.add_argument('output_file', nargs='?', metavar='<output-file>', default=sys.stdout, type=argparse.FileType('w'), help='Destination file to write to (default: stdout).')
args = parser.parse_args()
debug_printing_enabled = args.debug
#####
call_str_list = []
instance_variable_dict = collections.OrderedDict()
initialize_klass_dict = collections.OrderedDict()
for i in parse_all_method_infos():
debug_print(i)
if i.is_blocklisted():
debug_print("Blocklisted: " + str(i))
continue
call_str = format_call_to(i)
debug_print(call_str)
call_str_list.append(call_str)
instance_variable = format_instance_variable(i)
if instance_variable is not None:
debug_print(instance_variable)
instance_variable_dict[i.klass] = instance_variable
initialize_klass_dict[i.klass] = format_initialize_klass(i)
static_fields = indent_list([ value for (key, value) in instance_variable_dict.items() ], 2)
test_body = indent_list(call_str_list, 4)
initialize_classes = indent_list([ value for (key, value) in initialize_klass_dict.items() ], 4)
print(OUTPUT_TPL.substitute(static_fields="\n".join(static_fields),
test_body="\n".join(test_body),
initialize_classes="\n".join(initialize_classes)).
strip("\n"), \
file=args.output_file)
if __name__ == '__main__':
main()