This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
[gcjx] Patch: FYI: initial LLVM code
- From: Tom Tromey <tromey at redhat dot com>
- To: Java Patch List <java-patches at gcc dot gnu dot org>
- Date: 17 Jan 2006 17:48:53 -0700
- Subject: [gcjx] Patch: FYI: initial LLVM code
- Reply-to: tromey at redhat dot com
I'm checking this in on the gcjx branch.
Mike Emmel asked me to go ahead and check in the initial LLVM back
end. Here it is.
Tom
Index: ChangeLog
from Mike Emmel <mike.emmel@gmail.com>
* llvm/llvmgen.hh, llvm/llvmfunction.cc, llvm/llvmclass.cc,
llvm/llvmgen.cc, llvm/llvmclass.hh, llvm/llvmfunction.hh: New
files.
Index: llvm/llvmgen.hh
===================================================================
--- llvm/llvmgen.hh (revision 0)
+++ llvm/llvmgen.hh (revision 0)
@@ -0,0 +1,786 @@
+// Code generator for bytecode.
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// gcjx is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// gcjx 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
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with gcjx; see the file COPYING.LIB. If
+// not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#ifndef GCJX_LLVM_GEN_HH
+#define GCJX_LLVM_GEN_HH
+
+#include "codegen.hh"
+#include "llvm/Module.h"
+#include "llvm/llvmclass.hh"
+#include "llvm/llvmfunction.hh"
+
+using namespace llvm;
+
+/// This is the primary interface to bytecode generation.
+class llvm_code_generator : public visitor, public code_generator
+{
+public:
+
+ /// Construct a new bytecode code generator. Argument is the
+ /// compiler being used to generate code.
+ llvm_code_generator (compiler *, directory_cache &);
+ virtual ~llvm_code_generator();
+
+ /// This is called to generate code for a class and write it.
+ void generate (model_class *);
+ void generate (model_method *);
+
+ void visit_method (model_method *,
+ const std::list<ref_variable_decl> &,
+ const ref_block &);
+
+ void visit_assert (model_assert *, const ref_expression &,
+ const ref_expression &);
+
+ void visit_block (model_block *,
+ const std::list<ref_stmt> &);
+
+ void visit_bytecode_block (model_bytecode_block *, int, int, int,
+ const uint8 *);
+
+ void visit_break (model_break *, const ref_stmt &);
+
+ void visit_catch (model_catch *, const ref_variable_decl &,
+ const ref_block &);
+
+ void visit_continue (model_continue *, const ref_stmt &);
+
+ void visit_class_decl_stmt (model_class_decl_stmt *,
+ const ref_class &);
+
+ void visit_do (model_do *, const ref_expression &,
+ const ref_stmt &);
+
+ void visit_empty (model_empty *);
+
+ void visit_expression_stmt (model_expression_stmt *,
+ const ref_expression &);
+
+ void visit_for_enhanced (model_for_enhanced *,
+ const ref_stmt &, const ref_expression &,
+ const ref_variable_decl &);
+
+ void visit_for (model_for *, const ref_stmt &,
+ const ref_expression &, const ref_stmt &,
+ const ref_stmt &);
+
+ void visit_if (model_if *, const ref_expression &,
+ const ref_stmt &, const ref_stmt &);
+
+ void visit_label (model_label *, const ref_stmt &);
+
+ void visit_return (model_return *, const ref_expression &);
+
+ void visit_switch (model_switch *,
+ const ref_expression &,
+ const std::list<ref_switch_block> &);
+
+ void visit_switch_block (model_switch_block *,
+ const std::list<ref_stmt> &);
+
+ void visit_synchronized (model_synchronized *,
+ const ref_expression &,
+ const ref_stmt &);
+
+ void visit_throw (model_throw *, const ref_expression &);
+
+ void visit_try (model_try *, const ref_block &,
+ const std::list<ref_catch> &, const ref_block &);
+
+ void visit_variable_stmt (model_variable_stmt *,
+ const std::list<ref_variable_decl> &);
+
+ void visit_while (model_while *, const ref_expression &,
+ const ref_stmt &);
+
+
+ void visit_array_initializer (model_array_initializer *,
+ const ref_forwarding_type &,
+ const std::list<ref_expression> &);
+
+ void visit_array_ref (model_array_ref *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_assignment (model_assignment *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_method_invocation (model_method_invocation *,
+ model_method *,
+ const ref_expression &,
+ const std::list<ref_expression> &);
+
+ void visit_type_qualified_invocation (model_type_qualified_invocation *,
+ const model_method *,
+ const std::list<ref_expression> &,
+ bool);
+
+ void visit_super_invocation (model_super_invocation *,
+ const model_method *,
+ const std::list<ref_expression> &,
+ const ref_expression &);
+
+ void visit_this_invocation (model_this_invocation *,
+ const model_method *,
+ const std::list<ref_expression> &);
+
+ void visit_op_assignment (model_minus_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_mult_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_div_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_and_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_or_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_xor_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_mod_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_ls_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_rs_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_urs_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_op_assignment (model_plus_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_minus *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_mult *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_div *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_mod *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_and *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_or *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_xor *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_binary (model_plus *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_shift (model_left_shift *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_shift (model_right_shift *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_arith_shift (model_unsigned_right_shift *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_cast (model_cast *, const ref_forwarding_type &,
+ const ref_expression &);
+
+ void visit_class_ref (model_class_ref *,
+ const ref_forwarding_type &);
+
+ void visit_comparison (model_equal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_comparison (model_notequal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_comparison (model_lessthan *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_comparison (model_greaterthan *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_comparison (model_lessthanequal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_comparison (model_greaterthanequal *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_conditional (model_conditional *,
+ const ref_expression &,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_field_ref (model_field_ref *,
+ const ref_expression &,
+ model_field *);
+
+ void visit_field_initializer (model_field_initializer *,
+ model_field *);
+
+ void visit_field (model_field *);
+
+ void visit_instanceof (model_instanceof *,
+ const ref_expression &,
+ const ref_forwarding_type &);
+
+ void visit_logical_binary (model_lor *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_logical_binary (model_land *,
+ const ref_expression &,
+ const ref_expression &);
+
+ void visit_simple_literal (model_literal_base *,
+ const jboolean &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jbyte &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jchar &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jshort &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jint &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jlong &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jfloat &val);
+
+ void visit_simple_literal (model_literal_base *,
+ const jdouble &val);
+
+ void visit_string_literal (model_string_literal *,
+ const std::string &val);
+
+ void visit_new (model_new *, const model_method *,
+ const ref_forwarding_type &,
+ const std::list<ref_expression> &);
+
+ void visit_new_array (model_new_array *,
+ const ref_forwarding_type &,
+ const std::list<ref_expression> &,
+ const ref_expression &);
+
+ void visit_null_literal (model_null_literal *);
+
+ void visit_prefix_simple (model_prefix_plus *,
+ const ref_expression &);
+
+ void visit_prefix_simple (model_prefix_minus *,
+ const ref_expression &);
+
+ void visit_prefix_simple (model_bitwise_not *,
+ const ref_expression &);
+
+ void visit_prefix_simple (model_logical_not *,
+ const ref_expression &);
+
+ void visit_prefix_side_effect (model_prefix_plusplus *,
+ const ref_expression &);
+
+ void visit_prefix_side_effect (model_prefix_minusminus *,
+ const ref_expression &);
+
+ void visit_postfix_side_effect (model_postfix_plusplus *,
+ const ref_expression &);
+
+ void visit_postfix_side_effect (model_postfix_minusminus *,
+ const ref_expression &);
+
+ void visit_this (model_this *);
+
+ void visit_simple_variable_ref (model_simple_variable_ref *,
+ const model_variable_decl *);
+
+ void visit_forwarding_type (model_forwarding_type *,
+ model_type *)
+ {
+ // Nothing.
+ }
+
+ void visit_forwarding_resolved (model_forwarding_resolved *,
+ model_type *)
+ {
+ // Nothing.
+ }
+
+ void visit_forwarding_owned (model_forwarding_owned *,
+ const ref_type &)
+ {
+ // Nothing.
+ }
+
+ void visit_forwarding_simple (model_forwarding_simple *,
+ const std::list<std::string> &)
+ {
+ // Nothing.
+ }
+
+ void
+ visit_forwarding_array (model_forwarding_array *,
+ const owner<model_forwarding_type> &)
+ {
+ // Nothing.
+ }
+
+ void
+ visit_forwarding_element (model_forwarding_element *,
+ const owner<model_forwarding_type> &)
+ {
+ // Nothing.
+ }
+
+ void visit_forwarding_full (model_forwarding_full *,
+ const std::string &)
+ {
+ // Nothing.
+ }
+
+ void
+ visit_forwarding_inner (model_forwarding_inner *,
+ const std::list<std::string> &,
+ const owner<model_forwarding_type> &)
+ {
+ // Nothing.
+ }
+
+ void
+ visit_forwarding_parameterized (model_forwarding_parameterized *,
+ const owner<model_forwarding_type> &,
+ const std::list< owner<model_forwarding_type> > &)
+ {
+ // Nothing.
+ }
+ void visit_variable_decl (model_variable_decl *,
+ const std::string &,
+ const ref_forwarding_type &,
+ const ref_expression &,
+ bool,
+ bool);
+
+
+ void visit_parameter_decl (model_variable_decl *,
+ const std::string &,
+ const ref_forwarding_type &,
+ const ref_expression &,
+ bool,
+ bool)
+ {
+ // Nothing.
+ }
+
+ void visit_catch_decl (model_variable_decl *,
+ const std::string &,
+ const ref_forwarding_type &,
+ const ref_expression &,
+ bool,
+ bool)
+ {
+ // Nothing.
+ }
+
+ void visit_package (model_package *, const std::list<std::string> &)
+ {
+ // Nothing.
+ }
+
+ void visit_type (model_type *, const std::string &)
+ {
+ // Nothing.
+ }
+
+ void visit_identifier (model_identifier *, const std::string &)
+ {
+ // Nothing.
+ }
+
+ void visit_annotation_member (model_annotation_member *,
+ const ref_forwarding_type &)
+ {
+ // Nothing.
+ }
+
+ void visit_annotation_value (model_annotation_value *,
+ const std::string &, const ref_expression &)
+ {
+ // Nothing.
+ }
+
+ void visit_import_single (model_import_single *,
+ const std::list<std::string> &, model_class *)
+ {
+ // Nothing.
+ }
+
+ void visit_import_on_demand (model_import_on_demand *,
+ const std::list<std::string> &, Iname *, bool)
+ {
+ // Nothing.
+ }
+
+ void visit_static_import_single (model_static_import_single *,
+ const std::list<std::string> &,
+ model_class *, const std::string &)
+ {
+ // Nothing.
+ }
+
+ void visit_static_import_on_demand (model_static_import_on_demand *,
+ const std::list<std::string> &,
+ model_class *)
+ {
+ // Nothing.
+ }
+
+ void visit_unit_source (model_unit_source *, model_package *,
+ const std::list<ref_class> &,
+ const std::string &,
+ bool, const std::list<ref_import> &)
+ {
+ // Nothing.
+ }
+
+ void visit_unit_class (model_unit_class *, model_package *,
+ const std::list<ref_class> &,
+ const std::string &, bool)
+ {
+ // Nothing.
+ }
+
+ void visit_unit_fake (model_unit_fake *, model_package *,
+ const std::list<ref_class> &,
+ const std::string &, bool)
+ {
+ // Nothing.
+ }
+
+ void visit_abstract_method (model_abstract_method *am,
+ const std::list<ref_variable_decl> ¶ms,
+ const ref_block &body, model_method *)
+ {
+ visit_method (am, params, body);
+ }
+
+ void visit_annotation_type (model_annotation_type *at,
+ const std::string &descr,
+ const std::string &name)
+ {
+ visit_class (at, descr, name);
+ }
+
+ void visit_array_type (model_array_type *at, const std::string &descr,
+ const std::string &name, model_type *)
+ {
+ visit_class (at, descr, name);
+ }
+
+
+ void visit_class_instance (model_class_instance *ci,
+ const std::string &descr,
+ const std::string &name, model_class *)
+ {
+ visit_class (ci, descr, name);
+ }
+
+ void visit_constructor (model_constructor *c,
+ const std::list<ref_variable_decl> ¶ms,
+ const ref_block &body)
+ {
+ visit_method (c, params, body);
+ }
+
+ void visit_enum (model_enum *e, const std::string &descr,
+ const std::string &name,
+ const std::list<ref_enum_constant> &)
+ {
+ visit_class (e, descr, name);
+ }
+
+void visit_class (model_class *c, const std::string &descr,
+ const std::string &name);
+
+ void visit_enum_constant (model_enum_constant *ec,
+ const std::string &descr,
+ const std::string &name,
+ const std::list<ref_expression> &)
+ {
+ visit_class (ec, descr, name);
+ }
+
+ void visit_fp_primitive (model_primitive_base *, char, jfloat)
+ {
+ // Nothing.
+ }
+
+ void visit_fp_primitive (model_primitive_base *, char, jdouble)
+ {
+ // Nothing.
+ }
+
+ void visit_int_primitive (model_primitive_base *, char,
+ long long, long long, jbyte)
+ {
+ // Nothing.
+ }
+
+ void visit_int_primitive (model_primitive_base *, char,
+ long long, long long, jchar)
+ {
+ // Nothing.
+ }
+
+ void visit_int_primitive (model_primitive_base *, char,
+ long long, long long, jshort)
+ {
+ // Nothing.
+ }
+
+ void visit_int_primitive (model_primitive_base *, char,
+ long long, long long, jint)
+ {
+ // Nothing.
+ }
+
+ void visit_int_primitive (model_primitive_base *, char,
+ long long, long long, jlong)
+ {
+ // Nothing.
+ }
+
+ void visit_primitive_boolean (model_primitive_boolean *)
+ {
+ // Nothing.
+ }
+
+ void visit_initializer_block (model_initializer_block *ib,
+ const std::list<ref_stmt> &stmts, bool)
+ {
+ visit_block (ib, stmts);
+ }
+
+ void visit_new_primary (model_new_primary *np, const model_method *meth,
+ const ref_forwarding_type &klass,
+ const std::list<ref_expression> &args,
+ const std::string &,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_new (np, meth, klass, args);
+ }
+
+ void visit_null_type (model_null_type *nt, const std::string &descr)
+ {
+ visit_type (nt, descr);
+ }
+
+ void visit_phony_block (model_phony_block *pb,
+ const std::list<ref_stmt> &stmts)
+ {
+ visit_block (pb, stmts);
+ }
+
+ void visit_primordial_package (model_primordial_package *pp,
+ const std::list<std::string> &name)
+ {
+ visit_package (pp, name);
+ }
+
+ void visit_unnamed_package (model_unnamed_package *up,
+ const std::list<std::string> &name)
+ {
+ visit_package (up, name);
+ }
+
+ void visit_synthetic_this (model_synthetic_this *st)
+ {
+ visit_this (st);
+ }
+
+ void visit_this_outer (model_this_outer *to)
+ {
+ visit_this (to);
+ }
+
+ void
+ visit_type_variable (model_type_variable *tv,
+ const std::string &descr, const std::string &name,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_class (tv, descr, name);
+ }
+
+ void visit_void_type (model_void_type *vt, const std::string &descr)
+ {
+ visit_type (vt, descr);
+ }
+
+ void visit_wildcard (model_wildcard *w, const std::string &descr,
+ const std::string &name, bool,
+ const ref_forwarding_type &)
+ {
+ visit_class (w, descr, name);
+ }
+
+ void visit_javadoc (model_javadoc *, bool)
+ {
+ // Nothing.
+ }
+
+ void
+ visit_generic_invocation (model_method_invocation *mi,
+ model_method *meth,
+ const ref_expression &qual,
+ const std::list<ref_expression> &args,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_method_invocation (mi, meth, qual, args);
+ }
+
+ void
+ visit_generic_invocation (model_type_qualified_invocation *tqi,
+ const model_method *meth,
+ const std::list<ref_expression> &args,
+ bool is_super,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_type_qualified_invocation (tqi, meth, args, is_super);
+ }
+
+ void
+ visit_generic_invocation (model_super_invocation *si,
+ const model_method *meth,
+ const std::list<ref_expression> &args,
+ const ref_expression &finit,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_super_invocation (si, meth, args, finit);
+ }
+
+ void
+ visit_generic_invocation (model_this_invocation *ti,
+ const model_method *meth,
+ const std::list<ref_expression> &args,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_this_invocation (ti, meth, args);
+ }
+
+ void
+ visit_generic_invocation (model_new *n, const model_method *meth,
+ const ref_forwarding_type &klass,
+ const std::list<ref_expression> &args,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_new (n, meth, klass, args);
+ }
+
+ void
+ visit_generic_invocation (model_new_primary *np, const model_method *meth,
+ const ref_forwarding_type &klass,
+ const std::list<ref_expression> &args,
+ const std::string &simple_name,
+ const std::list<ref_forwarding_type> &type_params,
+ const std::list<ref_forwarding_type> &)
+ {
+ visit_new_primary (np, meth, klass, args, simple_name, type_params);
+ }
+
+ void
+ visit_annotation (model_annotation *, const ref_forwarding_type &,
+ const std::list<ref_annotation_value> &)
+ {
+ abort ();
+ }
+
+ void
+ visit_annotation_initializer (model_annotation_initializer *,
+ const ref_forwarding_type &,
+ const std::list<ref_expression> &)
+ {
+ abort ();
+ }
+
+ void visit_memberref_enum (model_memberref_enum *,
+ const ref_forwarding_type &,
+ const std::string &)
+ {
+ abort ();
+ }
+
+private:
+ // This maps our types to llvm types.
+ std::map<model_type *,Type *> typemap;
+ std::map<const model_variable_decl *,Value *> localmap;
+ std::map<const model_field *,Value *> fieldMap;
+ std::map<const model_method *,llvm_function *> methodMap;
+ Module* module;
+ llvm_function *currentMethod;
+ llvm_class *currentClass;
+ const Type * convertType( model_type *type );
+ Value * castToType(Value *V, const Type *Ty);
+ llvm_function * get_method (model_method * method );
+
+};
+
+#endif // GCJX_LLVM_GEN_HH
Index: llvm/llvmfunction.cc
===================================================================
--- llvm/llvmfunction.cc (revision 0)
+++ llvm/llvmfunction.cc (revision 0)
@@ -0,0 +1,233 @@
+// Code generator for llvm.
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// gcjx is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// gcjx 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
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with gcjx; see the file COPYING.LIB. If
+// not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#include "llvmfunction.hh"
+
+#include "llvm/SymbolTable.h"
+#include "llvm/Module.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
+#include "llvm/Constants.h"
+#include "llvm/Instructions.h"
+#include "llvm/Bytecode/Writer.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/DepthFirstIterator.h"
+
+/** Generate C code**/
+#include "llvm/Bytecode/Reader.h"
+#include "llvm/Target/SubtargetFeature.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetMachineRegistry.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Module.h"
+#include "llvm/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/PluginLoader.h"
+#include "llvm/Support/PassNameParser.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/System/Signals.h"
+#include "llvm/Config/config.h"
+/** End gnerate c code **/
+
+
+
+#include <list>
+#include <utility>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <memory>
+
+
+using namespace std;
+using namespace llvm;
+
+
+
+/// CastToType - Cast the specified value to the specified type if it is
+/// not already that type.
+Value *llvm_function::castToType(Value *V, const Type *Ty) {
+ if (V->getType() == Ty) return V;
+ if (Constant *C = dyn_cast<Constant>(V))
+ return ConstantExpr::getCast(C, Ty);
+
+ // Handle cast (cast bool X to T2) to bool as X, because this occurs all over
+ // the place.
+ if (CastInst *CI = dyn_cast<CastInst>(V))
+ if (Ty == Type::BoolTy && CI->getOperand(0)->getType() == Type::BoolTy)
+ return CI->getOperand(0);
+ return new CastInst(V, Ty, V->getName(), currentBlock);
+}
+
+
+/// emitBlock - Add the specified basic block to the end of the function. If
+/// the previous block falls through into it, add an explicit branch. Also,
+/// manage fixups for EH info.
+void llvm_function::emitBlock(BasicBlock *BB) {
+ // If the previous block falls through to BB, add an explicit branch.
+ if ( currentBlock->getTerminator() == 0) {
+ // If the previous block has no label and is empty, remove it: it is a
+ // post-terminator block.
+ if (currentBlock->getName().empty() && currentBlock->begin() == currentBlock->end())
+ currentBlock->eraseFromParent();
+ else {
+ // Otherwise, fall through to this block.
+ new BranchInst(BB, currentBlock);
+ }
+ }
+
+ // Add this block.
+ function->getBasicBlockList().push_back(BB);
+ currentBlock = BB; // It is now the current block.
+}
+
+/// CreateTemporary - Create a new alloca instruction of the specified type,
+/// inserting it into the entry block and returning it. The resulting
+/// instruction's type is a pointer to the specified type.
+AllocaInst *llvm_function::createTemporary(const Type *type) {
+ if (allocaInsertionPoint == 0) {
+ // Create a dummy instruction in the entry block as a marker to insert new
+ // alloc instructions before. It doesn't matter what this instruction is,
+ // it is dead. This allows us to insert allocas in order without having to
+ // scan for an insertion point.
+ allocaInsertionPoint = new CastInst(Constant::getNullValue(Type::IntTy),
+ Type::IntTy, "alloca point");
+ // Insert it as the first instruction in the entry block.
+ function->begin()->getInstList().insert(function->begin()->begin(),
+ allocaInsertionPoint);
+ }
+ return new AllocaInst(type, 0, "memtmp", allocaInsertionPoint);
+}
+
+
+
+
+llvm_function::llvm_function ( Module *owner)
+:isVarArg(0),
+ module(owner),
+ function(0),
+ name(""),
+ parameters(0),
+ varStack(),
+ returnType(0),
+ currentBlock(0),
+ returnBlock(0)
+{
+}
+
+void llvm_function::emitDeclaration() {
+ FunctionType *ftype = FunctionType::get(returnType,
+ parameters,isVarArg);
+ function = new Function(ftype,Function::ExternalLinkage,
+ name,module);
+
+ currentBlock = NULL;
+ //create the return block but add it later
+ //we will branch ahead to here on returns
+ returnBlock = new BasicBlock("return");
+}
+
+void llvm_function::emitFunction() {
+ emitBlock(returnBlock);
+ //If the function returns a value, get it into a register and return it now.
+ if (returnType != Type::VoidTy) {
+ //Value *returnValue = new LoadInst(DECL_LLVM(DECL_RESULT(FnDecl)), "retval", currentBlock);
+ //returnValue = castToType(RV, function->getReturnType());
+ //new ReturnInst(RV, currentBlock);
+ new ReturnInst( castToType(pop(),function->getReturnType()),currentBlock);
+ } else {
+ // Otherwise, just return.
+ new ReturnInst(currentBlock);
+ }
+}
+
+void llvm_function::emitReturnValue(){
+ new BranchInst(returnBlock,currentBlock);
+}
+
+void llvm_function::emitCall(llvm_function * callee){
+ vector<Value*> args;
+ args.reserve(callee->parameters.size());
+ for( unsigned int i = 0,e = callee->parameters.size(); i < e ; i++ )
+ {
+ args.push_back(pop());
+ }
+ CallInst *call=new CallInst(callee->function,args,callee->name,currentBlock);
+ if (callee->returnType != Type::VoidTy) {
+ push(call);
+ }
+}
+
+void llvm_function::setIsVarArg(bool b)
+{
+ isVarArg = b;
+}
+
+void llvm_function::setReturnType (const Type *type )
+{
+ returnType = type;
+}
+
+void llvm_function::setName (string inName )
+{
+ name = inName;
+}
+
+void llvm_function::initParameters (int size )
+{
+ parameters.reserve(size);
+}
+
+void llvm_function::addParameter (const Type * type,const string name)
+{
+ parameters.push_back(type);
+}
+
+
+Value * llvm_function::addLocalVariable (const Type * type,Value *size,
+ const string &name )
+{
+ if (allocaInsertionPoint == 0) {
+ // Create a dummy instruction in the entry block as a marker to insert new
+ // alloc instructions before. It doesn't matter what this instruction is,
+ // it is dead. This allows us to insert allocas in order without having to
+ // scan for an insertion point.
+ allocaInsertionPoint = new CastInst(Constant::getNullValue(Type::IntTy),
+ Type::IntTy, "alloca point");
+ // Insert it as the first instruction in the entry block.
+ function->begin()->getInstList().insert(function->begin()->begin(),
+ allocaInsertionPoint);
+ }
+
+ lvalue=new AllocaInst(type,size,name,allocaInsertionPoint);
+ return lvalue;
+}
+
+void llvm_function::startBlock()
+{
+ if( currentBlock == NULL ) {
+ currentBlock = new BasicBlock("EntryBlock",function);
+ }else {
+ emitBlock(new BasicBlock(""));
+ }
+}
+
Index: llvm/llvmclass.cc
===================================================================
--- llvm/llvmclass.cc (revision 0)
+++ llvm/llvmclass.cc (revision 0)
@@ -0,0 +1,79 @@
+// Code generator for llvm.
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// gcjx is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// gcjx 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
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with gcjx; see the file COPYING.LIB. If
+// not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#include "llvmclass.hh"
+
+#include "llvm/SymbolTable.h"
+#include "llvm/Module.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
+#include "llvm/Constants.h"
+#include "llvm/Instructions.h"
+#include "llvm/Bytecode/Writer.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/DepthFirstIterator.h"
+
+/** Generate C code**/
+#include "llvm/Bytecode/Reader.h"
+#include "llvm/Target/SubtargetFeature.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetMachineRegistry.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Module.h"
+#include "llvm/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/PluginLoader.h"
+#include "llvm/Support/PassNameParser.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/System/Signals.h"
+#include "llvm/Config/config.h"
+/** End gnerate c code **/
+
+
+
+#include <list>
+#include <utility>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <memory>
+
+
+using namespace std;
+using namespace llvm;
+
+
+llvm_class::llvm_class( Module *owner){
+ this->owner = owner;
+}
+
+void
+llvm_class::addField(const Type *type,string name )
+{
+ fields.push_back(type);
+}
+
+void
+llvm_class::emitStruct()
+{
+ classStruct = StructType::get(fields);
+}
Index: llvm/llvmgen.cc
===================================================================
--- llvm/llvmgen.cc (revision 0)
+++ llvm/llvmgen.cc (revision 0)
@@ -0,0 +1,1018 @@
+// Code generator for llvm.
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// gcjx is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// gcjx 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
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with gcjx; see the file COPYING.LIB. If
+// not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#include "typedefs.hh"
+#include "llvmgen.hh"
+#include "dump.hh"
+
+
+#include "llvm/SymbolTable.h"
+#include "llvm/Module.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
+#include "llvm/Constants.h"
+#include "llvm/Instructions.h"
+#include "llvm/Bytecode/Writer.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/DepthFirstIterator.h"
+
+/** Generate C code**/
+#include "llvm/Bytecode/Reader.h"
+#include "llvm/Target/SubtargetFeature.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetMachineRegistry.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Module.h"
+#include "llvm/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/PluginLoader.h"
+#include "llvm/Support/PassNameParser.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/System/Signals.h"
+//#include "llvm/Config/config.h"
+/** End gnerate c code **/
+
+
+
+#include <list>
+#include <utility>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <memory>
+
+
+using namespace std;
+using namespace llvm;
+
+// GetFileNameRoot - Helper function to get the basename of a filename.
+static inline string
+GetFileNameRoot(const string &InputFilename) {
+ string IFN = InputFilename;
+ string outputFilename;
+ int Len = IFN.length();
+ if ((Len > 2) &&
+ IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') {
+ outputFilename = string(IFN.begin(), IFN.end()-3); // s/.bc/.s/
+ } else {
+ outputFilename = IFN;
+ }
+ return outputFilename;
+}
+
+const Type * llvm_code_generator::convertType( model_type *type )
+{
+ if (typemap.find (type) == typemap.end ())
+ {
+ const Type *Ty;
+ assert (type->reference_p ());
+ model_class *klass = assert_cast<model_class *> (type);
+ Ty = OpaqueType::get();
+ module->addTypeName(klass->get_fully_qualified_name (),Ty);
+ //typemap[klass] = TypeDB.setType(type,PointerType::get(Ty));
+ typemap[klass] = PointerType::get(Ty);
+ return typemap[klass];
+ }
+ return typemap[type];
+}
+
+/// CastToType - Cast the specified value to the specified type if it is
+/// not already that type.
+Value *llvm_code_generator::castToType(Value *V, const Type *Ty) {
+#if 0
+ if (V->getType() == Ty) return V;
+ if (Constant *C = dyn_cast<Constant>(V))
+ return ConstantExpr::getCast(C, Ty);
+
+ // Handle cast (cast bool X to T2) to bool as X, because this occurs all over
+ // the place.
+ if (CastInst *CI = dyn_cast<CastInst>(V))
+ if (Ty == Type::BoolTy && CI->getOperand(0)->getType() == Type::BoolTy)
+ return CI->getOperand(0);
+ return new CastInst(V, Ty, V->getName(), currentBlock);
+#endif
+ return NULL;
+}
+
+
+llvm_code_generator::llvm_code_generator (compiler *comp,
+ directory_cache &dirs)
+: code_generator (dirs)
+{
+ // Set up all primitive types.
+ typemap[primitive_byte_type] = Type::SByteTy;
+ typemap[primitive_short_type] = Type::ShortTy;
+ typemap[primitive_int_type] = Type::IntTy;
+ typemap[primitive_long_type] = Type::LongTy;
+ typemap[primitive_float_type] = Type::FloatTy;
+ typemap[primitive_double_type] = Type::DoubleTy;
+ typemap[primitive_boolean_type] = Type::BoolTy;
+ typemap[primitive_char_type] = Type::UShortTy;
+ typemap[primitive_void_type] = Type::VoidTy;
+ typemap[null_type] = PointerType::get(OpaqueType::get());
+
+}
+
+ void
+llvm_code_generator::generate (model_class *klass)
+{
+ cout << "Class " << klass->get_name() << "\n";
+ string FeaturesStr;
+ string OutputFilename;
+ ostream *Out = 0;
+ const TargetMachineRegistry::Entry * target = TargetMachineRegistry::getList();
+
+ module = new Module(klass->get_name());
+ OutputFilename=GetFileNameRoot(klass->get_name())+".cgen";
+ //while( target != NULL ) {
+ cout << "Target=" << target->Name << "\n";
+ //target = target->getNext();
+ //}
+ auto_ptr<TargetMachine> targetArch(target->CtorFn(*module, 0, FeaturesStr));
+ assert(targetArch.get() && "Could not allocate target machine!");
+ TargetMachine &Target = *targetArch.get();
+ const TargetData &TD = Target.getTargetData();
+ // Build up all of the passes that we want to do to the module...
+ PassManager Passes;
+ Passes.add(new TargetData(TD));
+ Out = new ofstream(OutputFilename.c_str());
+ if (!Out->good()) {
+ cerr << ": error opening " << OutputFilename << "!\n";
+ delete Out;
+ return ;
+ }
+ sys::RemoveFileOnSignal(sys::Path(OutputFilename));
+ Target.addPassesToEmitFile(Passes,*Out,TargetMachine::AssemblyFile, true);
+
+
+ //visit the class
+ klass->visit(this);
+
+
+ // Output the bytecode file to stdout
+ //WriteBytecodeToFile(module, cout);
+ Passes.run(*module);
+ // Delete the ostream if it's not a stdout stream
+ if (Out != &cout) delete Out;
+ delete module;
+ //dump_tree(klass);
+}
+
+llvm_code_generator::~llvm_code_generator ()
+{
+ //XXX dunno about this is it enough ?
+ delete currentMethod;
+ delete this;
+}
+
+ void
+llvm_code_generator::generate( model_method *m)
+{
+ m->visit (this);
+}
+
+llvm_function *
+llvm_code_generator::get_method (model_method * method )
+{
+
+ llvm_function * function;
+ if (methodMap.find (method) == methodMap.end ()) {
+ function = new llvm_function(module);
+ const list<ref_variable_decl> & params = method->get_parameters ();
+cout << "Method " << method->get_name() << " " << method->get_pretty_name() << "\n";
+ function->setName(method->get_name());
+ function->initParameters(params.size());
+ for (list<ref_variable_decl>::const_iterator i = params.begin ();
+ i != params.end (); ++i)
+ {
+ model_type *type = (*i)->type ();
+ const Type *Ty =convertType(type);
+ function->addParameter(Ty,(*i)->get_name());
+ }
+ function->setReturnType(convertType(method->get_return_type()));
+ //finished with the declaration
+ function->emitDeclaration();
+ methodMap[method]=function;
+ return function;
+ }
+ function = methodMap[method];
+ assert(function != 0 );
+ return function;
+}
+
+void
+llvm_code_generator::visit_class (model_class *klass, const std::string &descr,
+ const std::string &name)
+{
+cout << " visit_class callled --------- " << descr << "++" << name << "\n";
+ currentClass = new llvm_class(module);
+ list<ref_field> fields = klass->get_fields ();
+ for (list<ref_field>::const_iterator i = fields.begin ();
+ i != fields.end (); ++i)
+ {
+ (*i).get ()->visit(this);
+ }
+ currentClass->emitStruct();
+
+
+ // First we generate code for the methods. Then we write the bytes
+ // for the fields and the methods in a separate step. We do this
+ // because code generation might require adding a new field.
+ list<ref_method> methods = klass->get_methods ();
+ for (list<ref_method>::const_iterator i = methods.begin ();
+ i != methods.end (); ++i)
+ {
+ generate ((*i).get ());
+ }
+
+
+}
+
+void
+llvm_code_generator::visit_field (model_field *field)
+{
+cout << " VISIT visit_field " << field->get_name() << "\n";
+ model_type *type = field->type ();
+ const Type *llvmType =convertType(type);
+ currentClass->addField(llvmType,field->get_name());
+#if 0
+ Value *size = 0;
+cout << "----> ADDING LOCAL VARIABLE " << name << "\n";
+ Value *location =currentMethod->addLocalVariable(Ty,size,name);
+ localmap[decl] = location;
+ if (init){
+ init->visit (this);
+ new StoreInst(currentMethod->pop(),location,currentMethod->currentBlock);
+ }
+#endif
+}
+
+void
+llvm_code_generator::visit_method (model_method * method,
+ const list<ref_variable_decl> & params,
+ const ref_block &block)
+{
+ currentMethod = get_method(method);
+ list<ref_variable_decl>::const_iterator i = params.begin ();
+ for (Function::arg_iterator arg = currentMethod->function->arg_begin ();
+ arg != currentMethod->function->arg_end(); arg++,i++)
+ {
+ model_variable_decl *decl = (*i).get();
+ localmap[decl]=arg;
+ }
+ //start walking
+ if( block)
+ block->visit(this);
+ //finish the function
+ currentMethod->emitFunction();
+}
+
+ void
+llvm_code_generator::visit_assert (model_assert *stmt,
+ const ref_expression &first,
+ const ref_expression &second)
+{
+cout << "VISIT model_assert \n";
+ if(first)
+ first->visit(this);
+ if(second)
+ second->visit(this);
+}
+
+ void
+llvm_code_generator::visit_block (model_block *block,
+ const list<ref_stmt> &statements)
+{
+ currentMethod->startBlock();
+ ::visit(this,statements);
+}
+
+ void
+llvm_code_generator::visit_bytecode_block (model_bytecode_block *block,
+ int, int, int, const uint8 *)
+{
+}
+
+ void
+llvm_code_generator::visit_break (model_break *brk, const ref_stmt &target)
+{
+cout << "VISIT break \n";
+}
+
+ void
+llvm_code_generator::visit_catch (model_catch *stmt,
+ const ref_variable_decl &var,
+ const ref_block &body)
+{
+cout << "VISIT catch \n";
+}
+
+void llvm_code_generator::visit_continue (model_continue *stmt,
+ const ref_stmt &target)
+{
+cout << "VISIT continue \n";
+}
+
+ void
+llvm_code_generator::visit_class_decl_stmt (model_class_decl_stmt *stmt,
+ const ref_class &klass)
+{
+cout << "VISIT ---- class decl_stmt \n";
+}
+
+void llvm_code_generator::visit_do (model_do *stmt, const ref_expression &cond,
+ const ref_stmt &body)
+{
+ if(cond)
+ cond->visit(this);
+cout << "VISIT do \n";
+}
+
+void llvm_code_generator::visit_empty (model_empty *)
+{
+cout << "VISIT empty \n";
+}
+
+void llvm_code_generator::visit_expression_stmt (model_expression_stmt *,
+ const ref_expression &expr)
+{
+ if( expr)
+ expr->visit(this);
+cout << " visit_expression_stmt \n";
+}
+
+void llvm_code_generator::visit_for_enhanced (model_for_enhanced *,
+ const ref_stmt &, const ref_expression & expr,
+ const ref_variable_decl &)
+{
+cout << "VISIT visit_for_enhanced \n";
+ if( expr)
+ expr->visit(this);
+}
+
+void llvm_code_generator::visit_for (model_for *, const ref_stmt &,
+ const ref_expression &expr, const ref_stmt &,
+ const ref_stmt &)
+{
+ if( expr)
+ expr->visit(this);
+cout << "VISIT visit_for\n";
+}
+
+void llvm_code_generator::visit_if (model_if *, const ref_expression &cond,
+ const ref_stmt &true_branch, const ref_stmt &false_branch)
+{
+ if( cond)
+ cond->visit(this);
+cout << "VISIT visit_if\n";
+}
+
+void llvm_code_generator::visit_label (model_label *, const ref_stmt &)
+{
+cout << "VISIT visit_label\n";
+}
+
+void llvm_code_generator::visit_return (model_return *, const ref_expression &expr)
+{
+ if(expr)
+ expr->visit(this);
+cout << "VISIT visit_return\n";
+ currentMethod->emitReturnValue();
+}
+
+void llvm_code_generator::visit_switch (model_switch *,
+ const ref_expression & expr,
+ const list<ref_switch_block> &)
+{
+ if(expr)
+ expr->visit(this);
+cout << "VISIT visit_switch\n";
+}
+
+void llvm_code_generator::visit_switch_block (model_switch_block *,
+ const list<ref_stmt> &)
+{
+cout << "VISIT visit_switch_block\n";
+}
+
+void llvm_code_generator::visit_synchronized (model_synchronized *,
+ const ref_expression & expr,
+ const ref_stmt &)
+{
+ if(expr)
+ expr->visit(this);
+cout << "VISIT visit_synchronized\n";
+}
+
+void llvm_code_generator::visit_throw (model_throw *, const ref_expression & expr)
+{
+ if(expr)
+ expr->visit(this);
+cout << "VISIT visit_throw\n";
+}
+
+void llvm_code_generator::visit_try (model_try *, const ref_block &,
+ const list<ref_catch> &, const ref_block &)
+{
+cout << "VISIT visit_try\n";
+}
+
+void llvm_code_generator::visit_variable_stmt (model_variable_stmt *,
+ const list<ref_variable_decl> & decls)
+{
+ for (list<ref_variable_decl>::const_iterator i = decls.begin ();
+ i != decls.end (); ++i)
+ {
+ (*i)->visit(this);
+ }
+}
+void llvm_code_generator::visit_variable_decl (model_variable_decl *decl,
+ const std::string &name,
+ const ref_forwarding_type &fortype,
+ const ref_expression &init,
+ bool isfinal,
+ bool isused)
+{
+ Value *size = 0;
+ model_type *type = decl->type ();
+ const Type *Ty =convertType(type);
+cout << "----> ADDING LOCAL VARIABLE " << name << "\n";
+ Value *location =currentMethod->addLocalVariable(Ty,size,name);
+ localmap[decl] = location;
+ if (init){
+ init->visit (this);
+ new StoreInst(currentMethod->pop(),location,currentMethod->currentBlock);
+ }
+}
+
+void llvm_code_generator::visit_while (model_while *, const ref_expression &cond,
+ const ref_stmt &body)
+{
+ if(cond)
+ cond->visit(this);
+ body->visit(this);
+
+cout << "VISIT visit_while\n";
+}
+
+void llvm_code_generator::visit_array_initializer (model_array_initializer *,
+ const ref_forwarding_type &,
+ const list<ref_expression> &)
+{
+cout << "VISIT visit_array_initializer \n";
+}
+
+void llvm_code_generator::visit_array_ref (model_array_ref *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT visit_array_ref \n";
+}
+
+void llvm_code_generator::visit_assignment (model_assignment *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT VARIALBEL ASSIGNMENT visit_assignment \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_minus_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT OP model_minus_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_mult_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT OP model_mult_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_div_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+}
+
+void llvm_code_generator::visit_op_assignment (model_and_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_and_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_or_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_or_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_plus_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_plus_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_xor_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_xor_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_mod_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT OP model_mod_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_ls_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT OP visit_op_assignment \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_rs_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT OP model_rs_equal \n";
+}
+
+void llvm_code_generator::visit_op_assignment (model_urs_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT OP model_urs_equal \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_minus *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_minus \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_mult *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_mult \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_div *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_div \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_mod *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_mod \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_and *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_and \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_or *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_or \n";
+}
+
+void llvm_code_generator::visit_arith_binary (model_xor *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_xor \n";
+}
+
+ void
+llvm_code_generator::visit_arith_binary (model_plus *,
+ const ref_expression &lhs,
+ const ref_expression &rhs)
+{
+ lhs->visit(this);
+ rhs->visit(this);
+ // Create the add instruction... does not insert...
+ Instruction *add =BinaryOperator::create(Instruction::Add,
+ currentMethod->pop(),currentMethod->pop(),"addresult",
+ currentMethod->currentBlock);
+ currentMethod->push(add);
+cout << "VISIT OP visit_arith_binary model_plus \n";
+}
+
+ void
+llvm_code_generator::visit_arith_shift (model_left_shift *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_left_shift \n";
+}
+
+ void
+llvm_code_generator::visit_arith_shift (model_right_shift *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_right_shift \n";
+
+}
+
+ void
+llvm_code_generator::visit_arith_shift (model_unsigned_right_shift *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_unsigned_right_shift \n";
+
+}
+
+ void
+llvm_code_generator::visit_cast (model_cast *, const ref_forwarding_type &,
+ const ref_expression &)
+{
+cout << "VISIT visit_cast \n";
+}
+
+ void
+llvm_code_generator::visit_class_ref (model_class_ref *,
+ const ref_forwarding_type &)
+{
+cout << "VISIT visit_class_ref \n";
+}
+
+ void
+llvm_code_generator::visit_comparison (model_equal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+
+cout << "VISIT visit_comparison model_equal \n";
+}
+
+ void
+llvm_code_generator::visit_comparison (model_notequal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_notequal \n";
+}
+
+ void
+llvm_code_generator::visit_comparison (model_lessthan *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_lessthan \n";
+
+}
+
+ void
+llvm_code_generator::visit_comparison (model_greaterthan *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_greaterthan \n";
+
+}
+
+ void
+llvm_code_generator::visit_comparison (model_lessthanequal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_lessthanequal \n";
+
+}
+
+ void
+llvm_code_generator::visit_comparison (model_greaterthanequal *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_greaterthanequal \n";
+
+}
+
+ void
+llvm_code_generator::visit_conditional (model_conditional *,
+ const ref_expression &,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_conditional \n";
+
+}
+
+ void
+llvm_code_generator::visit_field_ref (model_field_ref *,
+ const ref_expression &,
+ model_field *)
+{
+cout << "VISIT visit_field_ref \n";
+
+}
+
+ void
+llvm_code_generator::visit_field_initializer (model_field_initializer *,
+ model_field *)
+{
+cout << "VISIT FIELD INITIALIZER \n";
+
+}
+
+ void
+llvm_code_generator::visit_instanceof (model_instanceof *,
+ const ref_expression &,
+ const ref_forwarding_type &)
+{
+cout << "VISIT model_instanceof \n";
+
+}
+
+ void
+llvm_code_generator::visit_logical_binary (model_lor *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_lor \n";
+
+}
+
+ void
+llvm_code_generator::visit_logical_binary (model_land *,
+ const ref_expression &,
+ const ref_expression &)
+{
+cout << "VISIT model_land \n";
+
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jboolean &val)
+{
+cout << "VISIT visit_simple_literal jboolean \n";
+ currentMethod->rvalue = ConstantBool::get(Type::BoolTy,val);
+
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jbyte &val)
+{
+cout << "VISIT visit_simple_literal jbyte \n";
+ currentMethod->rvalue = ConstantSInt::get(Type::SByteTy,val);
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jchar &val)
+{
+cout << "VISIT visit_simple_literal jchar \n";
+ currentMethod->rvalue = ConstantSInt::get(Type::ShortTy,val);
+
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jshort &val)
+{
+cout << "VISIT visit_simple_literal jshort \n";
+ currentMethod->rvalue = ConstantSInt::get(Type::ShortTy,val);
+
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jint &val)
+{
+cout << "VISIT visit_simple_literal jint " << val << "\n";
+ currentMethod->push( ConstantSInt::get(Type::IntTy,val));
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jlong &val)
+{
+cout << "VISIT visit_simple_literal jlong \n";
+ currentMethod->rvalue = ConstantSInt::get(Type::LongTy,val);
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jfloat &val)
+{
+cout << "VISIT visit_simple_literal jfloat \n";
+ currentMethod->rvalue = ConstantFP::get(Type::FloatTy,val);
+
+}
+
+ void
+llvm_code_generator::visit_simple_literal (model_literal_base *,
+ const jdouble &val)
+{
+cout << "VISIT visit_simple_literal jdouble \n";
+ currentMethod->rvalue = ConstantFP::get(Type::DoubleTy,val);
+}
+
+ void
+llvm_code_generator::visit_string_literal (model_string_literal *,
+ const string &val)
+{
+cout << "VISIT visit_string_literal \n";
+}
+
+ void
+llvm_code_generator::visit_method_invocation (model_method_invocation *,
+ model_method * method,
+ const ref_expression &this_expr,
+ const list<ref_expression> &args)
+{
+ if( this_expr )
+ this_expr->visit(this);
+ if (method->static_p ()) {
+ //push this ?
+ }else {
+ //push class ?
+
+ }
+
+ for (std::list<ref_expression>::const_iterator i = args.begin ();
+ i != args.end (); ++i)
+ {
+ (*i)->visit (this);
+ }
+ llvm_function *function = get_method(method);
+ currentMethod->emitCall(function);
+}
+
+ void
+llvm_code_generator::visit_type_qualified_invocation (model_type_qualified_invocation *,
+ const model_method *,
+ const list<ref_expression> &,
+ bool)
+{
+
+cout << "VISIT visit_type_qualified_invocation \n";
+}
+
+ void
+llvm_code_generator::visit_super_invocation (model_super_invocation *,
+ const model_method *,
+ const list<ref_expression> &args,
+ const ref_expression &finit)
+{
+ for (list<ref_expression>::const_iterator i = args.begin ();
+ i != args.end (); ++i)
+ {
+ (*i)->visit (this);
+ }
+#if 0
+ /* field initializer */
+ if( finit )
+ finit->visit(this);
+#endif
+cout << "VISIT visit_super_invocation \n";
+}
+
+ void
+llvm_code_generator::visit_this_invocation (model_this_invocation *,
+ const model_method *,
+ const list<ref_expression> &)
+{
+cout << "VISIT visit_this_invocation \n";
+
+}
+
+ void
+llvm_code_generator::visit_new (model_new *, const model_method *,
+ const ref_forwarding_type &,
+ const list<ref_expression> &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_new_array (model_new_array *,
+ const ref_forwarding_type &,
+ const list<ref_expression> &,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_null_literal (model_null_literal *)
+{
+
+cout << "VISIT visit_null_literal \n";
+}
+
+ void
+llvm_code_generator::visit_prefix_simple (model_prefix_plus *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_prefix_simple (model_prefix_minus *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_prefix_simple (model_bitwise_not *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_prefix_simple (model_logical_not *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_prefix_side_effect (model_prefix_plusplus *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_prefix_side_effect (model_prefix_minusminus *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_postfix_side_effect (model_postfix_plusplus *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_postfix_side_effect (model_postfix_minusminus *,
+ const ref_expression &)
+{
+
+}
+
+ void
+llvm_code_generator::visit_this (model_this *)
+{
+
+cout << "VISIT visit_this \n";
+}
+
+ void
+llvm_code_generator::visit_simple_variable_ref (model_simple_variable_ref *,
+ const model_variable_decl *decl)
+{
+ currentMethod->push(localmap[decl]);
+cout << "VISIT visit_simple_variable_ref \n";
+
+}
+
+
Index: llvm/llvmclass.hh
===================================================================
--- llvm/llvmclass.hh (revision 0)
+++ llvm/llvmclass.hh (revision 0)
@@ -0,0 +1,45 @@
+// Code generator for bytecode.
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// gcjx is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// gcjx 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
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with gcjx; see the file COPYING.LIB. If
+// not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#ifndef GCJX_LLVM_CLASS_HH
+#define GCJX_LLVM_CLASS_HH
+
+#include "llvm/Module.h"
+#include "llvm/Instructions.h"
+#include "llvm/DerivedTypes.h"
+#include <stack>
+#include <iostream>
+
+using namespace llvm;
+using namespace std;
+
+class llvm_class
+{
+public:
+ Module *owner;
+ StructType *classStruct;
+ vector<const Type*> fields;
+ llvm_class( Module *owner);
+ void addField(const Type *type,string name );
+ void emitStruct();
+};
+
+#endif // GCJX_LLVM_CLASS_HH
Index: llvm/llvmfunction.hh
===================================================================
--- llvm/llvmfunction.hh (revision 0)
+++ llvm/llvmfunction.hh (revision 0)
@@ -0,0 +1,84 @@
+// Code generator for bytecode.
+
+// Copyright (C) 2004 Free Software Foundation, Inc.
+//
+// This file is part of GCC.
+//
+// gcjx is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Library General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// gcjx 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
+// Library General Public License for more details.
+//
+// You should have received a copy of the GNU Library General Public
+// License along with gcjx; see the file COPYING.LIB. If
+// not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+#ifndef GCJX_LLVM_FUNCTION_HH
+#define GCJX_LLVM_FUNCTION_HH
+
+#include "llvm/Module.h"
+#include "llvm/Instructions.h"
+#include <stack>
+#include <iostream>
+
+using namespace llvm;
+using namespace std;
+
+class llvm_function
+{
+public:
+ bool isVarArg;
+ Module* module;
+ Function *function;
+ string name;
+ vector<const Type*> parameters;
+ stack<Value*> varStack;
+ const Type *returnType;
+ BasicBlock *currentBlock;
+ BasicBlock *returnBlock;
+ //allocaInsertionPoint - Place to insert alloca instructions.
+ //Lazily created and managed by CreateTemporary.
+ Instruction *allocaInsertionPoint;
+ Value *lvalue;
+ Value *rvalue;
+
+ llvm_function(Module *owner);
+
+ Value * castToType(Value *V, const Type *type);
+ void emitBlock(BasicBlock *BB);
+ AllocaInst * createTemporary(const Type *type);
+ void initParameters( int size );
+ void addParameter(const Type *type,string name );
+ void setName(string name);
+ void setIsVarArg(bool b);
+ void setReturnType(const Type* type);
+ void startBlock();
+ Value *addLocalVariable (const Type * type,Value *size, const string &name );
+ void push(Value *var){
+ std::cout << "push\n";
+ varStack.push(var);
+ }
+ Value *pop(){
+ std::cout << "pop\n";
+ Value *var = varStack.top();
+ varStack.pop();
+ return var;
+ }
+
+ bool empty() {
+ return varStack.empty();
+ }
+ void emitDeclaration();
+ void emitFunction();
+ void emitReturnValue();
+ void llvm_function::emitCall(llvm_function * function);
+
+};
+
+#endif // GCJX_LLVM_GEN_HH