Source code
Revision control
Copy as Markdown
Other Tools
# Copyright (c) 2021, Alliance for Open Media. All rights reserved.
#
# This source code is subject to the terms of the BSD 2 Clause License and
# the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
# was not distributed with this source code in the LICENSE file, you can
# obtain it at www.aomedia.org/license/software. If the Alliance for Open
# Media Patent License 1.0 was not distributed with this source code in the
# PATENTS file, you can obtain it at www.aomedia.org/license/patent.
#
from __future__ import print_function
import sys
import os
import operator
from pycparser import c_parser, c_ast, parse_file
from math import *
from inspect import currentframe, getframeinfo
from collections import deque
def debug_print(frameinfo):
print('******** ERROR:', frameinfo.filename, frameinfo.lineno, '********')
class StructItem():
def __init__(self,
typedef_name=None,
struct_name=None,
struct_node=None,
is_union=False):
self.typedef_name = typedef_name
self.struct_name = struct_name
self.struct_node = struct_node
self.is_union = is_union
self.child_decl_map = None
def __str__(self):
return str(self.typedef_name) + ' ' + str(self.struct_name) + ' ' + str(
self.is_union)
def compute_child_decl_map(self, struct_info):
self.child_decl_map = {}
if self.struct_node != None and self.struct_node.decls != None:
for decl_node in self.struct_node.decls:
if decl_node.name == None:
for sub_decl_node in decl_node.type.decls:
sub_decl_status = parse_decl_node(struct_info, sub_decl_node)
self.child_decl_map[sub_decl_node.name] = sub_decl_status
else:
decl_status = parse_decl_node(struct_info, decl_node)
self.child_decl_map[decl_status.name] = decl_status
def get_child_decl_status(self, decl_name):
if self.child_decl_map == None:
debug_print(getframeinfo(currentframe()))
print('child_decl_map is None')
return None
if decl_name not in self.child_decl_map:
debug_print(getframeinfo(currentframe()))
print(decl_name, 'does not exist ')
return None
return self.child_decl_map[decl_name]
class StructInfo():
def __init__(self):
self.struct_name_dic = {}
self.typedef_name_dic = {}
self.enum_value_dic = {} # enum value -> enum_node
self.enum_name_dic = {} # enum name -> enum_node
self.struct_item_list = []
def get_struct_by_typedef_name(self, typedef_name):
if typedef_name in self.typedef_name_dic:
return self.typedef_name_dic[typedef_name]
else:
return None
def get_struct_by_struct_name(self, struct_name):
if struct_name in self.struct_name_dic:
return self.struct_name_dic[struct_name]
else:
debug_print(getframeinfo(currentframe()))
print('Cant find', struct_name)
return None
def update_struct_item_list(self):
# Collect all struct_items from struct_name_dic and typedef_name_dic
# Compute child_decl_map for each struct item.
for struct_name in self.struct_name_dic.keys():
struct_item = self.struct_name_dic[struct_name]
struct_item.compute_child_decl_map(self)
self.struct_item_list.append(struct_item)
for typedef_name in self.typedef_name_dic.keys():
struct_item = self.typedef_name_dic[typedef_name]
if struct_item.struct_name not in self.struct_name_dic:
struct_item.compute_child_decl_map(self)
self.struct_item_list.append(struct_item)
def update_enum(self, enum_node):
if enum_node.name != None:
self.enum_name_dic[enum_node.name] = enum_node
if enum_node.values != None:
enumerator_list = enum_node.values.enumerators
for enumerator in enumerator_list:
self.enum_value_dic[enumerator.name] = enum_node
def update(self,
typedef_name=None,
struct_name=None,
struct_node=None,
is_union=False):
"""T: typedef_name S: struct_name N: struct_node
T S N
case 1: o o o
typedef struct P {
int u;
} K;
T S N
case 2: o o x
typedef struct P K;
T S N
case 3: x o o
struct P {
int u;
};
T S N
case 4: o x o
typedef struct {
int u;
} K;
"""
struct_item = None
# Check whether struct_name or typedef_name is already in the dictionary
if struct_name in self.struct_name_dic:
struct_item = self.struct_name_dic[struct_name]
if typedef_name in self.typedef_name_dic:
struct_item = self.typedef_name_dic[typedef_name]
if struct_item == None:
struct_item = StructItem(typedef_name, struct_name, struct_node, is_union)
if struct_node.decls != None:
struct_item.struct_node = struct_node
if struct_name != None:
self.struct_name_dic[struct_name] = struct_item
if typedef_name != None:
self.typedef_name_dic[typedef_name] = struct_item
class StructDefVisitor(c_ast.NodeVisitor):
def __init__(self):
self.struct_info = StructInfo()
def visit_Struct(self, node):
if node.decls != None:
self.struct_info.update(None, node.name, node)
self.generic_visit(node)
def visit_Union(self, node):
if node.decls != None:
self.struct_info.update(None, node.name, node, True)
self.generic_visit(node)
def visit_Enum(self, node):
self.struct_info.update_enum(node)
self.generic_visit(node)
def visit_Typedef(self, node):
if node.type.__class__.__name__ == 'TypeDecl':
typedecl = node.type
if typedecl.type.__class__.__name__ == 'Struct':
struct_node = typedecl.type
typedef_name = node.name
struct_name = struct_node.name
self.struct_info.update(typedef_name, struct_name, struct_node)
elif typedecl.type.__class__.__name__ == 'Union':
union_node = typedecl.type
typedef_name = node.name
union_name = union_node.name
self.struct_info.update(typedef_name, union_name, union_node, True)
# TODO(angiebird): Do we need to deal with enum here?
self.generic_visit(node)
def build_struct_info(ast):
v = StructDefVisitor()
v.visit(ast)
struct_info = v.struct_info
struct_info.update_struct_item_list()
return v.struct_info
class DeclStatus():
def __init__(self, name, struct_item=None, is_ptr_decl=False):
self.name = name
self.struct_item = struct_item
self.is_ptr_decl = is_ptr_decl
def get_child_decl_status(self, decl_name):
if self.struct_item != None:
return self.struct_item.get_child_decl_status(decl_name)
else:
#TODO(angiebird): 2. Investigage the situation when a struct's definition can't be found.
return None
def __str__(self):
return str(self.struct_item) + ' ' + str(self.name) + ' ' + str(
self.is_ptr_decl)
def peel_ptr_decl(decl_type_node):
""" Remove PtrDecl and ArrayDecl layer """
is_ptr_decl = False
peeled_decl_type_node = decl_type_node
while peeled_decl_type_node.__class__.__name__ == 'PtrDecl' or peeled_decl_type_node.__class__.__name__ == 'ArrayDecl':
is_ptr_decl = True
peeled_decl_type_node = peeled_decl_type_node.type
return is_ptr_decl, peeled_decl_type_node
def parse_peeled_decl_type_node(struct_info, node):
struct_item = None
if node.__class__.__name__ == 'TypeDecl':
if node.type.__class__.__name__ == 'IdentifierType':
identifier_type_node = node.type
typedef_name = identifier_type_node.names[0]
struct_item = struct_info.get_struct_by_typedef_name(typedef_name)
elif node.type.__class__.__name__ == 'Struct':
struct_node = node.type
if struct_node.name != None:
struct_item = struct_info.get_struct_by_struct_name(struct_node.name)
else:
struct_item = StructItem(None, None, struct_node, False)
struct_item.compute_child_decl_map(struct_info)
elif node.type.__class__.__name__ == 'Union':
# TODO(angiebird): Special treatment for Union?
struct_node = node.type
if struct_node.name != None:
struct_item = struct_info.get_struct_by_struct_name(struct_node.name)
else:
struct_item = StructItem(None, None, struct_node, True)
struct_item.compute_child_decl_map(struct_info)
elif node.type.__class__.__name__ == 'Enum':
# TODO(angiebird): Special treatment for Union?
struct_node = node.type
struct_item = None
else:
print('Unrecognized peeled_decl_type_node.type',
node.type.__class__.__name__)
else:
# debug_print(getframeinfo(currentframe()))
# print(node.__class__.__name__)
#TODO(angiebird): Do we need to take care of this part?
pass
return struct_item
def parse_decl_node(struct_info, decl_node):
# struct_item is None if this decl_node is not a struct_item
decl_node_name = decl_node.name
decl_type_node = decl_node.type
is_ptr_decl, peeled_decl_type_node = peel_ptr_decl(decl_type_node)
struct_item = parse_peeled_decl_type_node(struct_info, peeled_decl_type_node)
return DeclStatus(decl_node_name, struct_item, is_ptr_decl)
def get_lvalue_lead(lvalue_node):
"""return '&' or '*' of lvalue if available"""
if lvalue_node.__class__.__name__ == 'UnaryOp' and lvalue_node.op == '&':
return '&'
elif lvalue_node.__class__.__name__ == 'UnaryOp' and lvalue_node.op == '*':
return '*'
return None
def parse_lvalue(lvalue_node):
"""get id_chain from lvalue"""
id_chain = parse_lvalue_recursive(lvalue_node, [])
return id_chain
def parse_lvalue_recursive(lvalue_node, id_chain):
"""cpi->rd->u -> (cpi->rd)->u"""
if lvalue_node.__class__.__name__ == 'ID':
id_chain.append(lvalue_node.name)
id_chain.reverse()
return id_chain
elif lvalue_node.__class__.__name__ == 'StructRef':
id_chain.append(lvalue_node.field.name)
return parse_lvalue_recursive(lvalue_node.name, id_chain)
elif lvalue_node.__class__.__name__ == 'ArrayRef':
return parse_lvalue_recursive(lvalue_node.name, id_chain)
elif lvalue_node.__class__.__name__ == 'UnaryOp' and lvalue_node.op == '&':
return parse_lvalue_recursive(lvalue_node.expr, id_chain)
elif lvalue_node.__class__.__name__ == 'UnaryOp' and lvalue_node.op == '*':
return parse_lvalue_recursive(lvalue_node.expr, id_chain)
else:
return None
class FuncDefVisitor(c_ast.NodeVisitor):
func_dictionary = {}
def visit_FuncDef(self, node):
func_name = node.decl.name
self.func_dictionary[func_name] = node
def build_func_dictionary(ast):
v = FuncDefVisitor()
v.visit(ast)
return v.func_dictionary
def get_func_start_coord(func_node):
return func_node.coord
def find_end_node(node):
node_list = []
for c in node:
node_list.append(c)
if len(node_list) == 0:
return node
else:
return find_end_node(node_list[-1])
def get_func_end_coord(func_node):
return find_end_node(func_node).coord
def get_func_size(func_node):
start_coord = get_func_start_coord(func_node)
end_coord = get_func_end_coord(func_node)
if start_coord.file == end_coord.file:
return end_coord.line - start_coord.line + 1
else:
return None
def save_object(obj, filename):
with open(filename, 'wb') as obj_fp:
pickle.dump(obj, obj_fp, protocol=-1)
def load_object(filename):
obj = None
with open(filename, 'rb') as obj_fp:
obj = pickle.load(obj_fp)
return obj
def get_av1_ast(gen_ast=False):
# TODO(angiebird): Generalize this path
c_filename = './av1_pp.c'
print('generate ast')
ast = parse_file(c_filename)
#save_object(ast, ast_file)
print('finished generate ast')
return ast
def get_func_param_id_map(func_def_node):
param_id_map = {}
func_decl = func_def_node.decl.type
param_list = func_decl.args.params
for decl in param_list:
param_id_map[decl.name] = decl
return param_id_map
class IDTreeStack():
def __init__(self, global_id_tree):
self.stack = deque()
self.global_id_tree = global_id_tree
def add_link_node(self, node, link_id_chain):
link_node = self.add_id_node(link_id_chain)
node.link_node = link_node
node.link_id_chain = link_id_chain
def push_id_tree(self, id_tree=None):
if id_tree == None:
id_tree = IDStatusNode()
self.stack.append(id_tree)
return id_tree
def pop_id_tree(self):
return self.stack.pop()
def add_id_seed_node(self, id_seed, decl_status):
return self.stack[-1].add_child(id_seed, decl_status)
def get_id_seed_node(self, id_seed):
idx = len(self.stack) - 1
while idx >= 0:
id_node = self.stack[idx].get_child(id_seed)
if id_node != None:
return id_node
idx -= 1
id_node = self.global_id_tree.get_child(id_seed)
if id_node != None:
return id_node
return None
def add_id_node(self, id_chain):
id_seed = id_chain[0]
id_seed_node = self.get_id_seed_node(id_seed)
if id_seed_node == None:
return None
if len(id_chain) == 1:
return id_seed_node
return id_seed_node.add_descendant(id_chain[1:])
def get_id_node(self, id_chain):
id_seed = id_chain[0]
id_seed_node = self.get_id_seed_node(id_seed)
if id_seed_node == None:
return None
if len(id_chain) == 1:
return id_seed_node
return id_seed_node.get_descendant(id_chain[1:])
def top(self):
return self.stack[-1]
class IDStatusNode():
def __init__(self, name=None, root=None):
if root is None:
self.root = self
else:
self.root = root
self.name = name
self.parent = None
self.children = {}
self.assign = False
self.last_assign_coord = None
self.refer = False
self.last_refer_coord = None
self.decl_status = None
self.link_id_chain = None
self.link_node = None
self.visit = False
def set_link_id_chain(self, link_id_chain):
self.set_assign(False)
self.link_id_chain = link_id_chain
self.link_node = self.root.get_descendant(link_id_chain)
def set_link_node(self, link_node):
self.set_assign(False)
self.link_id_chain = ['*']
self.link_node = link_node
def get_link_id_chain(self):
return self.link_id_chain
def get_concrete_node(self):
if self.visit == True:
# return None when there is a loop
return None
self.visit = True
if self.link_node == None:
self.visit = False
return self
else:
concrete_node = self.link_node.get_concrete_node()
self.visit = False
if concrete_node == None:
return self
return concrete_node
def set_assign(self, assign, coord=None):
concrete_node = self.get_concrete_node()
concrete_node.assign = assign
concrete_node.last_assign_coord = coord
def get_assign(self):
concrete_node = self.get_concrete_node()
return concrete_node.assign
def set_refer(self, refer, coord=None):
concrete_node = self.get_concrete_node()
concrete_node.refer = refer
concrete_node.last_refer_coord = coord
def get_refer(self):
concrete_node = self.get_concrete_node()
return concrete_node.refer
def set_parent(self, parent):
concrete_node = self.get_concrete_node()
concrete_node.parent = parent
def add_child(self, name, decl_status=None):
concrete_node = self.get_concrete_node()
if name not in concrete_node.children:
child_id_node = IDStatusNode(name, concrete_node.root)
concrete_node.children[name] = child_id_node
if decl_status == None:
# Check if the child decl_status can be inferred from its parent's
# decl_status
if self.decl_status != None:
decl_status = self.decl_status.get_child_decl_status(name)
child_id_node.set_decl_status(decl_status)
return concrete_node.children[name]
def get_child(self, name):
concrete_node = self.get_concrete_node()
if name in concrete_node.children:
return concrete_node.children[name]
else:
return None
def add_descendant(self, id_chain):
current_node = self.get_concrete_node()
for name in id_chain:
current_node.add_child(name)
parent_node = current_node
current_node = current_node.get_child(name)
current_node.set_parent(parent_node)
return current_node
def get_descendant(self, id_chain):
current_node = self.get_concrete_node()
for name in id_chain:
current_node = current_node.get_child(name)
if current_node == None:
return None
return current_node
def get_children(self):
current_node = self.get_concrete_node()
return current_node.children
def set_decl_status(self, decl_status):
current_node = self.get_concrete_node()
current_node.decl_status = decl_status
def get_decl_status(self):
current_node = self.get_concrete_node()
return current_node.decl_status
def __str__(self):
if self.link_id_chain is None:
return str(self.name) + ' a: ' + str(int(self.assign)) + ' r: ' + str(
int(self.refer))
else:
return str(self.name) + ' -> ' + ' '.join(self.link_id_chain)
def collect_assign_refer_status(self,
id_chain=None,
assign_ls=None,
refer_ls=None):
if id_chain == None:
id_chain = []
if assign_ls == None:
assign_ls = []
if refer_ls == None:
refer_ls = []
id_chain.append(self.name)
if self.assign:
info_str = ' '.join([
' '.join(id_chain[1:]), 'a:',
str(int(self.assign)), 'r:',
str(int(self.refer)),
str(self.last_assign_coord)
])
assign_ls.append(info_str)
if self.refer:
info_str = ' '.join([
' '.join(id_chain[1:]), 'a:',
str(int(self.assign)), 'r:',
str(int(self.refer)),
str(self.last_refer_coord)
])
refer_ls.append(info_str)
for c in self.children:
self.children[c].collect_assign_refer_status(id_chain, assign_ls,
refer_ls)
id_chain.pop()
return assign_ls, refer_ls
def show(self):
assign_ls, refer_ls = self.collect_assign_refer_status()
print('---- assign ----')
for item in assign_ls:
print(item)
print('---- refer ----')
for item in refer_ls:
print(item)
class FuncInOutVisitor(c_ast.NodeVisitor):
def __init__(self,
func_def_node,
struct_info,
func_dictionary,
keep_body_id_tree=True,
call_param_map=None,
global_id_tree=None,
func_history=None,
unknown=None):
self.func_dictionary = func_dictionary
self.struct_info = struct_info
self.param_id_map = get_func_param_id_map(func_def_node)
self.parent_node = None
self.global_id_tree = global_id_tree
self.body_id_tree = None
self.keep_body_id_tree = keep_body_id_tree
if func_history == None:
self.func_history = {}
else:
self.func_history = func_history
if unknown == None:
self.unknown = []
else:
self.unknown = unknown
self.id_tree_stack = IDTreeStack(global_id_tree)
self.id_tree_stack.push_id_tree()
#TODO move this part into a function
for param in self.param_id_map:
decl_node = self.param_id_map[param]
decl_status = parse_decl_node(self.struct_info, decl_node)
descendant = self.id_tree_stack.add_id_seed_node(decl_status.name,
decl_status)
if call_param_map is not None and param in call_param_map:
# This is a function call.
# Map the input parameter to the caller's nodes
# TODO(angiebird): Can we use add_link_node here?
descendant.set_link_node(call_param_map[param])
def get_id_tree_stack(self):
return self.id_tree_stack
def generic_visit(self, node):
prev_parent = self.parent_node
self.parent_node = node
for c in node:
self.visit(c)
self.parent_node = prev_parent
# TODO rename
def add_new_id_tree(self, node):
self.id_tree_stack.push_id_tree()
self.generic_visit(node)
id_tree = self.id_tree_stack.pop_id_tree()
if self.parent_node == None and self.keep_body_id_tree == True:
# this is function body
self.body_id_tree = id_tree
def visit_For(self, node):
self.add_new_id_tree(node)
def visit_Compound(self, node):
self.add_new_id_tree(node)
def visit_Decl(self, node):
if node.type.__class__.__name__ != 'FuncDecl':
decl_status = parse_decl_node(self.struct_info, node)
descendant = self.id_tree_stack.add_id_seed_node(decl_status.name,
decl_status)
if node.init is not None:
init_id_chain = self.process_lvalue(node.init)
if init_id_chain != None:
if decl_status.struct_item is None:
init_descendant = self.id_tree_stack.add_id_node(init_id_chain)
if init_descendant != None:
init_descendant.set_refer(True, node.coord)
else:
self.unknown.append(node)
descendant.set_assign(True, node.coord)
else:
self.id_tree_stack.add_link_node(descendant, init_id_chain)
else:
self.unknown.append(node)
else:
descendant.set_assign(True, node.coord)
self.generic_visit(node)
def is_lvalue(self, node):
if self.parent_node is None:
# TODO(angiebird): Do every lvalue has parent_node != None?
return False
if self.parent_node.__class__.__name__ == 'StructRef':
return False
if self.parent_node.__class__.__name__ == 'ArrayRef' and node == self.parent_node.name:
# if node == self.parent_node.subscript, the node could be lvalue
return False
if self.parent_node.__class__.__name__ == 'UnaryOp' and self.parent_node.op == '&':
return False
if self.parent_node.__class__.__name__ == 'UnaryOp' and self.parent_node.op == '*':
return False
return True
def process_lvalue(self, node):
id_chain = parse_lvalue(node)
if id_chain == None:
return id_chain
elif id_chain[0] in self.struct_info.enum_value_dic:
return None
else:
return id_chain
def process_possible_lvalue(self, node):
if self.is_lvalue(node):
id_chain = self.process_lvalue(node)
lead_char = get_lvalue_lead(node)
# make sure the id is not an enum value
if id_chain == None:
self.unknown.append(node)
return
descendant = self.id_tree_stack.add_id_node(id_chain)
if descendant == None:
self.unknown.append(node)
return
decl_status = descendant.get_decl_status()
if decl_status == None:
descendant.set_assign(True, node.coord)
descendant.set_refer(True, node.coord)
self.unknown.append(node)
return
if self.parent_node.__class__.__name__ == 'Assignment':
if node is self.parent_node.lvalue:
if decl_status.struct_item != None:
if len(id_chain) > 1:
descendant.set_assign(True, node.coord)
elif len(id_chain) == 1:
if lead_char == '*':
descendant.set_assign(True, node.coord)
else:
right_id_chain = self.process_lvalue(self.parent_node.rvalue)
if right_id_chain != None:
self.id_tree_stack.add_link_node(descendant, right_id_chain)
else:
#TODO(angiebird): 1.Find a better way to deal with this case.
descendant.set_assign(True, node.coord)
else:
debug_print(getframeinfo(currentframe()))
else:
descendant.set_assign(True, node.coord)
elif node is self.parent_node.rvalue:
if decl_status.struct_item is None:
descendant.set_refer(True, node.coord)
if lead_char == '&':
descendant.set_assign(True, node.coord)
else:
left_id_chain = self.process_lvalue(self.parent_node.lvalue)
left_lead_char = get_lvalue_lead(self.parent_node.lvalue)
if left_id_chain != None:
if len(left_id_chain) > 1:
descendant.set_refer(True, node.coord)
elif len(left_id_chain) == 1:
if left_lead_char == '*':
descendant.set_refer(True, node.coord)
else:
#TODO(angiebird): Check whether the other node is linked to this node.
pass
else:
self.unknown.append(self.parent_node.lvalue)
debug_print(getframeinfo(currentframe()))
else:
self.unknown.append(self.parent_node.lvalue)
debug_print(getframeinfo(currentframe()))
else:
debug_print(getframeinfo(currentframe()))
elif self.parent_node.__class__.__name__ == 'UnaryOp':
# TODO(angiebird): Consider +=, *=, -=, /= etc
if self.parent_node.op == '--' or self.parent_node.op == '++' or\
self.parent_node.op == 'p--' or self.parent_node.op == 'p++':
descendant.set_assign(True, node.coord)
descendant.set_refer(True, node.coord)
else:
descendant.set_refer(True, node.coord)
elif self.parent_node.__class__.__name__ == 'Decl':
#The logic is at visit_Decl
pass
elif self.parent_node.__class__.__name__ == 'ExprList':
#The logic is at visit_FuncCall
pass
else:
descendant.set_refer(True, node.coord)
def visit_ID(self, node):
# If the parent is a FuncCall, this ID is a function name.
if self.parent_node.__class__.__name__ != 'FuncCall':
self.process_possible_lvalue(node)
self.generic_visit(node)
def visit_StructRef(self, node):
self.process_possible_lvalue(node)
self.generic_visit(node)
def visit_ArrayRef(self, node):
self.process_possible_lvalue(node)
self.generic_visit(node)
def visit_UnaryOp(self, node):
if node.op == '&' or node.op == '*':
self.process_possible_lvalue(node)
self.generic_visit(node)
def visit_FuncCall(self, node):
if node.name.__class__.__name__ == 'ID':
if node.name.name in self.func_dictionary:
if node.name.name not in self.func_history:
self.func_history[node.name.name] = True
func_def_node = self.func_dictionary[node.name.name]
call_param_map = self.process_func_call(node, func_def_node)
visitor = FuncInOutVisitor(func_def_node, self.struct_info,
self.func_dictionary, False,
call_param_map, self.global_id_tree,
self.func_history, self.unknown)
visitor.visit(func_def_node.body)
else:
self.unknown.append(node)
self.generic_visit(node)
def process_func_call(self, func_call_node, func_def_node):
# set up a refer/assign for func parameters
# return call_param_map
call_param_ls = func_call_node.args.exprs
call_param_map = {}
func_decl = func_def_node.decl.type
decl_param_ls = func_decl.args.params
for param_node, decl_node in zip(call_param_ls, decl_param_ls):
id_chain = self.process_lvalue(param_node)
if id_chain != None:
descendant = self.id_tree_stack.add_id_node(id_chain)
if descendant == None:
self.unknown.append(param_node)
else:
decl_status = descendant.get_decl_status()
if decl_status != None:
if decl_status.struct_item == None:
if decl_status.is_ptr_decl == True:
descendant.set_assign(True, param_node.coord)
descendant.set_refer(True, param_node.coord)
else:
descendant.set_refer(True, param_node.coord)
else:
call_param_map[decl_node.name] = descendant
else:
self.unknown.append(param_node)
else:
self.unknown.append(param_node)
return call_param_map
def build_global_id_tree(ast, struct_info):
global_id_tree = IDStatusNode()
for node in ast.ext:
if node.__class__.__name__ == 'Decl':
# id tree is for tracking assign/refer status
# we don't care about function id because they can't be changed
if node.type.__class__.__name__ != 'FuncDecl':
decl_status = parse_decl_node(struct_info, node)
descendant = global_id_tree.add_child(decl_status.name, decl_status)
return global_id_tree
class FuncAnalyzer():
def __init__(self):
self.ast = get_av1_ast()
self.struct_info = build_struct_info(self.ast)
self.func_dictionary = build_func_dictionary(self.ast)
self.global_id_tree = build_global_id_tree(self.ast, self.struct_info)
def analyze(self, func_name):
if func_name in self.func_dictionary:
func_def_node = self.func_dictionary[func_name]
visitor = FuncInOutVisitor(func_def_node, self.struct_info,
self.func_dictionary, True, None,
self.global_id_tree)
visitor.visit(func_def_node.body)
root = visitor.get_id_tree_stack()
root.top().show()
else:
print(func_name, "doesn't exist")
if __name__ == '__main__':
fa = FuncAnalyzer()
fa.analyze('tpl_get_satd_cost')
pass