/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package adobe.abc;
import java.io.*;
import java.util.*;
import static macromedia.asc.embedding.avmplus.ActionBlockConstants.*;
import adobe.abc.GlobalOptimizer.*;
import static adobe.abc.OptimizerConstants.*;
import static java.lang.Boolean.TRUE;
import static java.lang.Boolean.FALSE;
/**
* @author Steven Johnson
*/
public class AbcThunkGen
{
static class IndentingPrintWriter extends PrintWriter
{
int indent;
IndentingPrintWriter(Writer w)
{
super(w);
}
public void println()
{
for (int i=0; i < indent; i++)
print(" ");
super.println();
}
public void println(String s)
{
for (int i=0; i < indent; i++)
print(" ");
super.println(s);
}
}
public static void main(String[] args) throws IOException
{
if (args.length == 0)
{
System.out.println("usage: AbcThunkGen [-import foo.abc] bar.abc");
return;
}
byte[] abcdata = null;
InputAbc ia = null;
String filename = null;
GlobalOptimizer go = new GlobalOptimizer();
go.ALLOW_NATIVE_CTORS = true;
for (int i = 0; i < args.length; ++i)
{
if(args[i].equals("-import"))
{
i++;
InputAbc imported = go.new InputAbc();
imported.readAbc(load(args[i]));
continue;
}
if (ia != null)
{
throw new RuntimeException("only one abc file may be specified");
}
filename = args[i];
abcdata = load(filename);
ia = go.new InputAbc();
ia.readAbc(abcdata);
}
if (ia == null)
{
throw new RuntimeException("an abc file must be specified");
}
String scriptname = filename.substring(0,filename.lastIndexOf('.'));
emitNatives(ia, abcdata, scriptname, TypeCache.instance().namespaceNames);
}
static byte[] load(String filename) throws IOException
{
InputStream in = new FileInputStream(filename);
try
{
byte[] before = new byte[in.available()];
in.read(before);
return before;
}
finally
{
in.close();
}
}
private InputAbc abc;
private byte[] abcdata;
private String name;
private Map<Namespace,Name> namespaceNames;
private PrintWriter out_h;
private IndentingPrintWriter out_c;
private Map<Integer,String> native_methods;
private HashMap<Type,Integer> class_id_map;
private HashMap<String, HashMap<String, Method>> unique_thunks;
AbcThunkGen(InputAbc abc, byte[] abcdata, String name, Map<Namespace,Name> namespaceNames,
PrintWriter out_h, IndentingPrintWriter out_c)
{
this.abc = abc;
this.abcdata = abcdata;
this.name = name;
this.namespaceNames = namespaceNames;
this.out_h = out_h;
this.out_c = out_c;
this.native_methods = new TreeMap<Integer,String>();
this.unique_thunks = new HashMap<String, HashMap<String, Method>>();
this.class_id_map = new HashMap<Type,Integer>();
for (int i = 0; i < abc.classes.length; ++i)
this.class_id_map.put(abc.classes[i], i);
}
static void emitNatives(InputAbc abc, byte[] abcdata, String name,
Map<Namespace,Name> namespaceNames) throws IOException
{
PrintWriter out_h = new PrintWriter(new FileWriter(name+".h2"));
IndentingPrintWriter out_c = new IndentingPrintWriter(new FileWriter(name+".cpp2"));
try
{
AbcThunkGen ngen = new AbcThunkGen(abc, abcdata, name, namespaceNames, out_h, out_c);
ngen.emit();
}
finally
{
out_c.close();
out_h.close();
}
}
private void emit()
{
// header file - definitions & native method decls
out_h.println("/* machine generated file -- do not edit */");
out_c.println("/* machine generated file -- do not edit */");
out_h.println("#define AVMTHUNK_VERSION 1");
out_h.printf("const uint32_t %s_abc_class_count = %d;\n",name,abc.classes.length);
out_h.printf("const uint32_t %s_abc_script_count = %d;\n",name,abc.scripts.length);
out_h.printf("const uint32_t %s_abc_method_count = %d;\n",name,abc.methods.length);
out_h.printf("const uint32_t %s_abc_length = %d;\n",name,abcdata.length);
out_h.printf("extern const uint8_t %s_abc_data[%d];\n",name,abcdata.length);
for (int i = 0; i < abc.scripts.length; ++i)
{
Type s = abc.scripts[i];
// not enough info in the ABC to recover the original name (eg abcpackage_Foo_as)
// so output identifiers based on the native script functions found
for (Binding bb : s.defs.values())
{
if (bb.method != null && bb.method.isNative())
out_h.println("const uint32_t abcscript_"+ bb.getName() + " = " + i + ";");
}
emitSourceTraits("", s);
}
out_c.println("// "+unique_thunks.size()+" unique thunks");
for (String sig: unique_thunks.keySet())
{
out_c.println();
HashMap<String, Method> users = unique_thunks.get(sig);
assert(users.size() > 0);
Method m = null;
for (String native_name: users.keySet())
{
out_c.println("// "+native_name);
m = users.get(native_name);
}
String thunkname = name+"_"+sig;
// emit both with and without-cookie versions, since we can't tell at this point which
// might be used for a particular method. rely on linker to strip the unused ones.
emitThunk(thunkname, m, false);
emitThunk(thunkname, m, true);
for (String native_name: users.keySet())
{
m = users.get(native_name);
out_h.printf(" const uint32_t %s = %d;\n", native_name, m.id);
// use #define here (rather than constants) to avoid the linker including them and thus preventing dead-stripping
// (sad but true, happens in some environments)
out_h.printf(" #define %s_thunk %s_thunk\n", native_name, thunkname);
out_h.printf(" #define %s_thunkc %s_thunkc\n", native_name, thunkname);
}
}
// cpp file - abc data, thunks
out_c.println("const uint8_t "+name+"_abc_data["+abcdata.length+"] = {");
for (int i=0, n=abcdata.length; i < n; i++)
{
int x = abcdata[i] & 255;
if (x < 10) out_c.print(" ");
else if (x < 100) out_c.print(' ');
out_c.print(x);
if (i+1 < n) out_c.print(", ");
if (i%16 == 15) out_c.println();
}
out_c.println("};");
}
void emitSourceTraits(String prefix, Type s)
{
if (s.init != null && s.init.isNative())
{
String native_name = prefix + s.getName();
gatherThunk(native_name, s.init);
}
for (Binding b: s.defs.values())
{
Namespace ns = b.getName().nsset(0);
String id = prefix + propLabel(b, ns);
String ctype = null;
if (b.method != null)
{
if(b.method.isNative())
emitSourceMethod(prefix, b, ns);
}
else if (GlobalOptimizer.isClass(b))
{
emitSourceClass(b, ns);
}
}
}
static String to_cname(String nm)
{
// munge symbols that will make C unhappy
nm = nm.replace("+", "_");
nm = nm.replace("-", "_");
nm = nm.replace("?", "_");
nm = nm.replace("!", "_");
nm = nm.replace("<", "_");
nm = nm.replace(">", "_");
nm = nm.replace("=", "_");
nm = nm.replace("(", "_");
nm = nm.replace(")", "_");
nm = nm.replace("\"", "_");
nm = nm.replace("'", "_");
nm = nm.replace("*", "_");
nm = nm.replace(" ", "_");
nm = nm.replace(".", "_");
nm = nm.replace("$", "_");
nm = nm.replace(":", "_");
nm = nm.replace("/", "_");
return nm;
}
void emitSourceClass(Binding b, Namespace ns)
{
String label = ns_prefix(ns, true) + to_cname(b.getName().name);
Type c = b.type.t;
out_h.println();
out_h.println("const uint32_t abcclass_"+ label + " = " + class_id_map.get(c) + ";");
emitSourceTraits(label+"_", c);
emitSourceTraits(label+"_", c.itype);
}
String ctype_i(int ctype, boolean allowObject)
{
switch (ctype)
{
case CTYPE_OBJECT:
if (allowObject)
return "AvmObject";
// else fall thru
case CTYPE_ATOM:
return "AvmBox";
case CTYPE_VOID:
return "void";
case CTYPE_BOOLEAN:
return "AvmBoolArg";
case CTYPE_INT:
return "int32_t";
case CTYPE_UINT:
return "uint32_t";
case CTYPE_DOUBLE:
return "double";
case CTYPE_STRING:
return "AvmString";
case CTYPE_NAMESPACE:
return "AvmNamespace";
default:
assert(false);
return "";
}
}
void emitSourceMethod(String prefix, Binding b, Namespace ns)
{
Method m = b.method;
String native_name = prefix + propLabel(b, ns);
if (GlobalOptimizer.isGetter(b))
native_name += "_get";
else if (GlobalOptimizer.isSetter(b))
native_name += "_set";
gatherThunk(native_name, m);
}
String ns_prefix(Namespace ns, boolean iscls)
{
if (!ns.isPublic() && !ns.isInternal())
{
if (ns.isPrivate() && !iscls) return "private_";
if (ns.isProtected()) return "protected_";
if (namespaceNames.containsKey(ns)) return namespaceNames.get(ns) + "_";
}
String p = to_cname(ns.uri);
if (p.length() > 0) p += "_";
return p;
}
String propLabel(Binding b, Namespace ns)
{
return ns_prefix(ns, false) + b.getName().name;
}
int defValCType(Object value)
{
if (value instanceof Integer)
return CTYPE_INT;
if (value instanceof Long)
return CTYPE_UINT;
if (value instanceof Double)
{
double d = (Double)value;
if (d == (int)(d))
return CTYPE_INT;
if (d == (long)(d))
return CTYPE_UINT;
return CTYPE_DOUBLE;
}
if (value instanceof String)
return CTYPE_STRING;
// sorry, not supported in natives
// if (value instanceof Namespace)
// return CTYPE_NAMESPACE;
if (value == TRUE)
return CTYPE_BOOLEAN;
if (value == FALSE)
return CTYPE_BOOLEAN;
if (value.toString() == "undefined")
return CTYPE_ATOM;
if (value.toString() == "null")
return CTYPE_ATOM;
throw new RuntimeException("unsupported default-value type "+value.toString());
}
String defValStr(Object value)
{
// for numeric values, just emit inline rather than looking up in const pool
if (value instanceof Integer)
return value.toString();
if (value instanceof Long)
return value.toString();
if (value instanceof Double)
{
double d = (Double)value;
if (d == (int)(d))
return Integer.toString((int)d, 10);
if (d == (long)(d))
return Long.toString((long)d, 10) + "U";
if (Double.isInfinite(d))
return (d < 0.0) ? "kAvmThunkNegInfinity" : "kAvmThunkInfinity";
if (Double.isNaN(d))
return "kAvmThunkNaN";
return value.toString();
}
if (value instanceof String)
{
for (int i = 0; i < abc.strings.length; ++i)
if (abc.strings[i].equals(value))
return "AvmThunkConstant_AvmString("+Integer.toString(i, 10)+")/* \""+abc.strings[i]+"\" */";
}
// sorry, not supported in natives
// if (value instanceof Namespace)
// return value.toString();
if (value == TRUE)
return "true";
if (value == FALSE)
return "false";
if (value.toString() == "undefined")
return "kAvmThunkUndefined";
if (value.toString() == "null")
return "kAvmThunkNull";
throw new RuntimeException("unsupported default-value type "+value.toString());
}
int get_optional_count(Method m)
{
int optional_count = 0;
if (m.values != null)
for (Object v : m.values)
if (v != null)
optional_count++;
return optional_count;
}
String sigChar(int ctype, boolean allowObject)
{
switch (ctype)
{
case CTYPE_OBJECT:
if (allowObject)
return "o";
// else fall thru
case CTYPE_ATOM:
return "a";
case CTYPE_VOID:
return "v";
case CTYPE_BOOLEAN:
return "b";
case CTYPE_INT:
return "i";
case CTYPE_UINT:
return "u";
case CTYPE_DOUBLE:
return "d";
case CTYPE_STRING:
return "s";
case CTYPE_NAMESPACE:
return "n";
default:
assert(false);
return "";
}
}
String thunkSig(Method m)
{
String sig = sigChar(m.returns.t.ctype, false)+"2";
if (m.returns.t.ctype == CTYPE_DOUBLE)
sig += sigChar(CTYPE_DOUBLE, false);
else
sig += sigChar(CTYPE_ATOM, false);
sig += "_";
for (int i = 0; i < m.getParams().length; ++i)
{
sig += sigChar(m.getParams()[i].t.ctype, true);
}
if (m.hasOptional())
{
int param_count = m.getParams().length - 1;
int optional_count = get_optional_count(m);
for (int i = param_count - optional_count + 1; i <= param_count; i++)
{
String dts = sigChar(defValCType(m.values[i]), true);
String defval = to_cname(defValStr(m.values[i]));
sig += "_opt" + dts + defval;
}
}
else
{
assert(get_optional_count(m) == 0);
}
if (m.needsRest())
sig += "_rest";
return sig;
}
void gatherThunk(String native_name, Method m)
{
native_methods.put(m.id, native_name);
String sig = thunkSig(m);
if (!unique_thunks.containsKey(sig))
unique_thunks.put(sig, new HashMap<String, Method>());
unique_thunks.get(sig).put(native_name, m);
}
void emitThunk(String name, Method m, boolean cookie)
{
String ret = ctype_i(m.returns.t.ctype, false);
out_h.printf("extern AvmThunkRetType_%s AVMTHUNK_CALLTYPE %s_thunk%s(AvmMethodEnv env, uint32_t argc, const AvmBox* argv);\n", ret, name, cookie?"c":"");
out_c.printf("AvmThunkRetType_%s AVMTHUNK_CALLTYPE %s_thunk%s(AvmMethodEnv env, uint32_t argc, const AvmBox* argv)\n", ret, name, cookie?"c":"");
out_c.println("{");
out_c.indent++;
int param_count = m.getParams().length-1;
assert(param_count >= 0);
int optional_count = get_optional_count(m);
assert(optional_count <= param_count);
String argszprev = "0";
for (int i = 0; i < m.getParams().length; ++i)
{
String cts = ctype_i(m.getParams()[i].t.ctype, true);
if (i == 0)
out_c.println("const uint32_t argoff0 = 0;");
else
out_c.println("const uint32_t argoff"+i+" = argoff"+(i-1)+" + "+argszprev+";");
argszprev = "AvmThunkArgSize_"+cts;
}
if (m.needsRest())
{
out_c.println("const uint32_t argoffV = argoff"+(m.getParams().length-1)+" + "+argszprev+";");
}
int argct = m.getParams().length + (cookie?1:0) + (m.needsRest()?2:0);
String[] argvals = new String[argct];
String[] argtypes = new String[argct];
int argsidx = 0;
for (int i = 0; i < m.getParams().length; ++i)
{
String cts = ctype_i(m.getParams()[i].t.ctype, true);
String val = "AvmThunkUnbox_"+cts+"(argv[argoff" + i + "])";
if (i > param_count - optional_count)
{
String dts = ctype_i(defValCType(m.values[i]), true);
String defval = defValStr(m.values[i]);
if (!dts.equals(cts))
defval = "AvmThunkCoerce_"+dts+"_"+cts+"("+defval+")";
val = "(argc < "+i+" ? "+defval+" : "+val+")";
}
argvals[argsidx] = val;
argtypes[argsidx] = cts;
argsidx++;
if (i == 0 && cookie)
{
argvals[argsidx] = "AVMTHUNK_GET_COOKIE(env)";
argtypes[argsidx] = "int32_t";
argsidx++;
}
}
if (m.needsRest())
{
argvals[argsidx] = "(argc <= "+param_count+" ? NULL : argv + argoffV)";
argtypes[argsidx] = "const AvmBox*";
argsidx++;
argvals[argsidx] = "(argc <= "+param_count+" ? 0 : argc - "+param_count+")";
argtypes[argsidx] = "uint32_t";
argsidx++;
}
if (!m.hasOptional() && !m.needsRest())
out_c.println("(void)argc;");
out_c.println("AVMTHUNK_DEBUG_ENTER(env)");
String call = "";
if (m.returns.t.ctype != CTYPE_VOID)
call += "const "+ret+" ret = ";
call += "AVMTHUNK_CALL_FUNCTION_"+(argvals.length-1)+"(AVMTHUNK_GET_HANDLER(env), "+ret;
out_c.println(call);
out_c.indent++;
for (int i = 0; i < argvals.length; ++i)
{
out_c.println(", " + argtypes[i] + ", " + argvals[i]);
}
out_c.indent--;
out_c.println(");");
out_c.println("AVMTHUNK_DEBUG_EXIT(env)");
out_c.println("return AvmToRetType_"+ret+"(ret);");
out_c.indent--;
out_c.println("}");
}
}