test/hotspot/jtreg/testlibrary/jittester/src/jdk/test/lib/jittester/SymbolTable.java

/*
 * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package jdk.test.lib.jittester;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import java.util.stream.Collectors;
import jdk.test.lib.jittester.types.TypeKlass;


public class SymbolTable {

    private static final Stack<HashMap<Type, ArrayList<Symbol>>> SYMBOL_STACK
            = new Stack<>();
    private static int VARIABLE_NUMBER = 0;
    private static int FUNCTION_NUMBER = 0;

    private static void initExternalSymbols() {

        String classList = ProductionParams.addExternalSymbols.value();
        if (classList.equals("all")) {
            TypeList.getReferenceTypes()
                    .forEach(Type::exportSymbols);
        } else {
            String[] splittedList = classList.split(",");
            for (Type type : TypeList.getReferenceTypes()) {
                for (String str : splittedList) {
                    if (type.getName().equals(str)) {
                        type.exportSymbols();
                        break;
                    }
                }
            }
        }

    }

    static {
        SYMBOL_STACK.push(new HashMap<>());
        if (!ProductionParams.disableExternalSymbols.value()) {
            initExternalSymbols();
        }
    }

    public static void add(Symbol symbol) {
        HashMap<Type, ArrayList<Symbol>> vars = SYMBOL_STACK.peek();
        if (!vars.containsKey(symbol.type)) {
            vars.put(symbol.type, new ArrayList<>());
        }
        vars.get(symbol.type).add(symbol);
    }

    public static void remove(Symbol symbol) {
        HashMap<Type, ArrayList<Symbol>> vars = SYMBOL_STACK.peek();
        if (vars.containsKey(symbol.type)) {
            ArrayList<Symbol> symbolsOfType = vars.get(symbol.type);
            symbolsOfType.remove(symbol);
            if (symbolsOfType.isEmpty()) {
                vars.remove(symbol.type);
            }
        }
    }

    protected static Collection<Symbol> get(Type type) {
        HashMap<Type, ArrayList<Symbol>> vars = SYMBOL_STACK.peek();
        if (vars.containsKey(type)) {
            return vars.get(type);
        }
        return new ArrayList<>();
    }

    public static Collection<Symbol> get(Type type, Class<?> classToCheck) {
        HashMap<Type, ArrayList<Symbol>> vars = SYMBOL_STACK.peek();
        if (vars.containsKey(type)) {
            return vars.get(type).stream()
                .filter(classToCheck::isInstance)
                .collect(Collectors.toList());
        }
        return new ArrayList<>();
    }

    protected static Collection<Symbol> get(TypeKlass typeKlass, Type type,
            Class<?> classToCheck) {
        HashMap<Type, ArrayList<Symbol>> vars = SYMBOL_STACK.peek();
        if (vars.containsKey(type)) {
            ArrayList<Symbol> result = new ArrayList<>();
            for (Symbol symbol : vars.get(type)) {
                if (classToCheck.isInstance(symbol) && typeKlass.equals(symbol.owner)) {
                    result.add(symbol);
                }
            }
            return result;
        }
        return new ArrayList<>();
    }

    protected static HashMap<Type, ArrayList<Symbol>> getAll() {
        return SYMBOL_STACK.peek();
    }

    protected static HashMap<Type, ArrayList<Symbol>> getAll(Class<?> classToCheck) {
        HashMap<Type, ArrayList<Symbol>> result = new HashMap<>();

        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                if (classToCheck.isInstance(symbol)) {
                    if (!result.containsKey(type)) {
                        result.put(type, new ArrayList<>());
                    }
                    result.get(type).add(symbol);
                }
            }
        }

        return result;
    }

    protected static HashMap<Type, ArrayList<Symbol>> getAll(TypeKlass typeKlass, Class<?> classToCheck) {
        HashMap<Type, ArrayList<Symbol>> result = new HashMap<>();

        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType =  SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                if (classToCheck.isInstance(symbol) && typeKlass.equals(symbol.owner)) {
                    if (!result.containsKey(type)) {
                        result.put(type, new ArrayList<>());
                    }
                    result.get(type).add(symbol);
                }
            }
        }

        return result;
    }

    protected static ArrayList<Symbol> getAllCombined() {
        ArrayList<Symbol> result = new ArrayList<>();
        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                result.add(symbol);
            }
        }

        return result;
    }

    public static ArrayList<Symbol> getAllCombined(Class<?> classToCheck) {
        ArrayList<Symbol> result = new ArrayList<>();
        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                if (classToCheck.isInstance(symbol)) {
                    result.add(symbol);
                }
            }
        }

        return result;
    }

    public static ArrayList<Symbol> getAllCombined(TypeKlass typeKlass, Class<?> classToCheck) {
        ArrayList<Symbol> result = new ArrayList<>();
        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                if (classToCheck.isInstance(symbol) && typeKlass.equals(symbol.owner)) {
                    result.add(symbol);
                }
            }
        }

        return result;
    }

    public static ArrayList<Symbol> getAllCombined(TypeKlass typeKlass) {
        ArrayList<Symbol> result = new ArrayList<>();
        for (Type t : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(t);
            for (Symbol symbol : symbolsOfType) {
                if (typeKlass.equals(symbol.owner)) {
                    result.add(symbol);
                }
            }
        }

        return result;
    }

    protected static ArrayList<Symbol> getAllCombined(String name, Class<?> classToCheck) {
        ArrayList<Symbol> result = new ArrayList<>();
        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                if (classToCheck.isInstance(symbol) && name.equals(symbol.name)) {
                    result.add(symbol);
                }
            }
        }

        return result;
    }

    public static Symbol get(String name, Class<?> classToCheck) {
        for (Type type : SYMBOL_STACK.peek().keySet()) {
            ArrayList<Symbol> symbolsOfType = SYMBOL_STACK.peek().get(type);
            for (Symbol symbol : symbolsOfType) {
                if (classToCheck.isInstance(symbol) && name.equals(symbol.name)) {
                    return symbol;
                }
            }
        }
        return null;
    }

    public static void removeAll() {
        SYMBOL_STACK.clear();
        SYMBOL_STACK.push(new HashMap<>());
        VARIABLE_NUMBER = 0;
        FUNCTION_NUMBER = 0;
        if (!ProductionParams.disableExternalSymbols.value()) {
            initExternalSymbols();
        }
    }

    public static void push() {
        // Do deep cloning..
        HashMap<Type, ArrayList<Symbol>> prev = SYMBOL_STACK.peek();
        HashMap<Type, ArrayList<Symbol>> top = new HashMap<>(prev.size());
        SYMBOL_STACK.push(top);
        for (Map.Entry<Type, ArrayList<Symbol>> entry : prev.entrySet()) {
            ArrayList<Symbol> prevArray = entry.getValue();
            ArrayList<Symbol> topArray = new ArrayList<>(prevArray.size());
            top.put(entry.getKey(), topArray);
            for (Symbol symbol : prevArray) {
                topArray.add(symbol.copy());
            }
        }
    }

    public static void merge() {
        // Merging means moving element at the top of stack one step down, while removing the
        // previous element.
        HashMap<Type, ArrayList<Symbol>> top = SYMBOL_STACK.pop();
        SYMBOL_STACK.pop();
        SYMBOL_STACK.push(top);
    }

    public static void pop() {
        SYMBOL_STACK.pop();
    }

    public static int getNextVariableNumber() {
        return ++VARIABLE_NUMBER;
    }

    public static int getNextFunctionNumber() {
        return ++FUNCTION_NUMBER;
    }

    @Override
    public String toString() {
        return SYMBOL_STACK.toString();
    }
}