1 /*

     2  * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright 2008, 2009, 2010 Red Hat, Inc.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    25 

    26 #include "incls/_precompiled.incl"

    27 #include "incls/_sharkCompiler.cpp.incl"

    28 

    29 #include <fnmatch.h>

    30 

    31 using namespace llvm;

    32 

    33 #if SHARK_LLVM_VERSION >= 27

    34 namespace {

    35   cl::opt<std::string>

    36   MCPU("mcpu");

    37 

    38   cl::list<std::string>

    39   MAttrs("mattr",

    40          cl::CommaSeparated);

    41 }

    42 #endif

    43 

    44 SharkCompiler::SharkCompiler()

    45   : AbstractCompiler() {

    46   // Create the lock to protect the memory manager and execution engine

    47   _execution_engine_lock = new Monitor(Mutex::leaf, "SharkExecutionEngineLock");

    48   MutexLocker locker(execution_engine_lock());

    49 

    50   // Make LLVM safe for multithreading

    51   if (!llvm_start_multithreaded())

    52     fatal("llvm_start_multithreaded() failed");

    53 

    54   // Initialize the native target

    55   InitializeNativeTarget();

    56 

    57   // Create the two contexts which we'll use

    58   _normal_context = new SharkContext("normal");

    59   _native_context = new SharkContext("native");

    60 

    61   // Create the memory manager

    62   _memory_manager = new SharkMemoryManager();

    63 

    64 #if SHARK_LLVM_VERSION >= 27

    65   // Finetune LLVM for the current host CPU.

    66   StringMap<bool> Features;

    67   bool gotCpuFeatures = llvm::sys::getHostCPUFeatures(Features);

    68   std::string cpu("-mcpu=" + llvm::sys::getHostCPUName());

    69 

    70   std::vector<const char*> args;

    71   args.push_back(""); // program name

    72   args.push_back(cpu.c_str());

    73 

    74   std::string mattr("-mattr=");

    75   if(gotCpuFeatures){

    76     for(StringMap<bool>::iterator I = Features.begin(),

    77       E = Features.end(); I != E; ++I){

    78       if(I->second){

    79         std::string attr(I->first());

    80         mattr+="+"+attr+",";

    81       }

    82     }

    83     args.push_back(mattr.c_str());

    84   }

    85 

    86   args.push_back(0);  // terminator

    87   cl::ParseCommandLineOptions(args.size() - 1, (char **) &args[0]);

    88 

    89   // Create the JIT

    90   std::string ErrorMsg;

    91 

    92   EngineBuilder builder(_normal_context->module());

    93   builder.setMCPU(MCPU);

    94   builder.setMAttrs(MAttrs);

    95   builder.setJITMemoryManager(memory_manager());

    96   builder.setEngineKind(EngineKind::JIT);

    97   builder.setErrorStr(&ErrorMsg);

    98   _execution_engine = builder.create();

    99 

   100   if (!execution_engine()) {

   101     if (!ErrorMsg.empty())

   102       printf("Error while creating Shark JIT: %s\n",ErrorMsg.c_str());

   103     else

   104       printf("Unknown error while creating Shark JIT\n");

   105     exit(1);

   106   }

   107 

   108   execution_engine()->addModule(

   109     _native_context->module());

   110 #else

   111   _execution_engine = ExecutionEngine::createJIT(

   112     _normal_context->module_provider(),

   113     NULL, memory_manager(), CodeGenOpt::Default);

   114   execution_engine()->addModuleProvider(

   115     _native_context->module_provider());

   116 #endif

   117 

   118   // All done

   119   mark_initialized();

   120 }

   121 

   122 void SharkCompiler::initialize() {

   123   ShouldNotCallThis();

   124 }

   125 

   126 void SharkCompiler::compile_method(ciEnv*    env,

   127                                    ciMethod* target,

   128                                    int       entry_bci) {

   129   assert(is_initialized(), "should be");

   130   ResourceMark rm;

   131   const char *name = methodname(

   132     target->holder()->name()->as_utf8(), target->name()->as_utf8());

   133 

   134   // Do the typeflow analysis

   135   ciTypeFlow *flow;

   136   if (entry_bci == InvocationEntryBci)

   137     flow = target->get_flow_analysis();

   138   else

   139     flow = target->get_osr_flow_analysis(entry_bci);

   140   if (flow->failing())

   141     return;

   142   if (SharkPrintTypeflowOf != NULL) {

   143     if (!fnmatch(SharkPrintTypeflowOf, name, 0))

   144       flow->print_on(tty);

   145   }

   146 

   147   // Create the recorders

   148   Arena arena;

   149   env->set_oop_recorder(new OopRecorder(&arena));

   150   OopMapSet oopmaps;

   151   env->set_debug_info(new DebugInformationRecorder(env->oop_recorder()));

   152   env->debug_info()->set_oopmaps(&oopmaps);

   153   env->set_dependencies(new Dependencies(env));

   154 

   155   // Create the code buffer and builder

   156   CodeBuffer hscb("Shark", 256 * K, 64 * K);

   157   hscb.initialize_oop_recorder(env->oop_recorder());

   158   MacroAssembler *masm = new MacroAssembler(&hscb);

   159   SharkCodeBuffer cb(masm);

   160   SharkBuilder builder(&cb);

   161 

   162   // Emit the entry point

   163   SharkEntry *entry = (SharkEntry *) cb.malloc(sizeof(SharkEntry));

   164 

   165   // Build the LLVM IR for the method

   166   Function *function = SharkFunction::build(env, &builder, flow, name);

   167 

   168   // Generate native code.  It's unpleasant that we have to drop into

   169   // the VM to do this -- it blocks safepoints -- but I can't see any

   170   // other way to handle the locking.

   171   {

   172     ThreadInVMfromNative tiv(JavaThread::current());

   173     generate_native_code(entry, function, name);

   174   }

   175 

   176   // Install the method into the VM

   177   CodeOffsets offsets;

   178   offsets.set_value(CodeOffsets::Deopt, 0);

   179   offsets.set_value(CodeOffsets::Exceptions, 0);

   180   offsets.set_value(CodeOffsets::Verified_Entry,

   181                     target->is_static() ? 0 : wordSize);

   182 

   183   ExceptionHandlerTable handler_table;

   184   ImplicitExceptionTable inc_table;

   185 

   186   env->register_method(target,

   187                        entry_bci,

   188                        &offsets,

   189                        0,

   190                        &hscb,

   191                        0,

   192                        &oopmaps,

   193                        &handler_table,

   194                        &inc_table,

   195                        this,

   196                        env->comp_level(),

   197                        false,

   198                        false);

   199 }

   200 

   201 nmethod* SharkCompiler::generate_native_wrapper(MacroAssembler* masm,

   202                                                 methodHandle    target,

   203                                                 BasicType*      arg_types,

   204                                                 BasicType       return_type) {

   205   assert(is_initialized(), "should be");

   206   ResourceMark rm;

   207   const char *name = methodname(

   208     target->klass_name()->as_utf8(), target->name()->as_utf8());

   209 

   210   // Create the code buffer and builder

   211   SharkCodeBuffer cb(masm);

   212   SharkBuilder builder(&cb);

   213 

   214   // Emit the entry point

   215   SharkEntry *entry = (SharkEntry *) cb.malloc(sizeof(SharkEntry));

   216 

   217   // Build the LLVM IR for the method

   218   SharkNativeWrapper *wrapper = SharkNativeWrapper::build(

   219     &builder, target, name, arg_types, return_type);

   220 

   221   // Generate native code

   222   generate_native_code(entry, wrapper->function(), name);

   223 

   224   // Return the nmethod for installation in the VM

   225   return nmethod::new_native_nmethod(target,

   226                                      masm->code(),

   227                                      0,

   228                                      0,

   229                                      wrapper->frame_size(),

   230                                      wrapper->receiver_offset(),

   231                                      wrapper->lock_offset(),

   232                                      wrapper->oop_maps());

   233 }

   234 

   235 void SharkCompiler::generate_native_code(SharkEntry* entry,

   236                                          Function*   function,

   237                                          const char* name) {

   238   // Print the LLVM bitcode, if requested

   239   if (SharkPrintBitcodeOf != NULL) {

   240     if (!fnmatch(SharkPrintBitcodeOf, name, 0))

   241       function->dump();

   242   }

   243 

   244   // Compile to native code

   245   address code = NULL;

   246   context()->add_function(function);

   247   {

   248     MutexLocker locker(execution_engine_lock());

   249     free_queued_methods();

   250 

   251     if (SharkPrintAsmOf != NULL) {

   252 #if SHARK_LLVM_VERSION >= 27

   253 #ifndef NDEBUG

   254       if (!fnmatch(SharkPrintAsmOf, name, 0)) {

   255         llvm::SetCurrentDebugType(X86_ONLY("x86-emitter") NOT_X86("jit"));

   256         llvm::DebugFlag = true;

   257       }

   258       else {

   259         llvm::SetCurrentDebugType("");

   260         llvm::DebugFlag = false;

   261       }

   262 #endif // !NDEBUG

   263 #else

   264       // NB you need to patch LLVM with http://tinyurl.com/yf3baln for this

   265       std::vector<const char*> args;

   266       args.push_back(""); // program name

   267       if (!fnmatch(SharkPrintAsmOf, name, 0))

   268         args.push_back("-debug-only=x86-emitter");

   269       else

   270         args.push_back("-debug-only=none");

   271       args.push_back(0);  // terminator

   272       cl::ParseCommandLineOptions(args.size() - 1, (char **) &args[0]);

   273 #endif // SHARK_LLVM_VERSION

   274     }

   275     memory_manager()->set_entry_for_function(function, entry);

   276     code = (address) execution_engine()->getPointerToFunction(function);

   277   }

   278   entry->set_entry_point(code);

   279   entry->set_function(function);

   280   entry->set_context(context());

   281   address code_start = entry->code_start();

   282   address code_limit = entry->code_limit();

   283 

   284   // Register generated code for profiling, etc

   285   if (JvmtiExport::should_post_dynamic_code_generated())

   286     JvmtiExport::post_dynamic_code_generated(name, code_start, code_limit);

   287 

   288   // Print debug information, if requested

   289   if (SharkTraceInstalls) {

   290     tty->print_cr(

   291       " [%p-%p): %s (%d bytes code)",

   292       code_start, code_limit, name, code_limit - code_start);

   293   }

   294 }

   295 

   296 void SharkCompiler::free_compiled_method(address code) {

   297   // This method may only be called when the VM is at a safepoint.

   298   // All _thread_in_vm threads will be waiting for the safepoint to

   299   // finish with the exception of the VM thread, so we can consider

   300   // ourself the owner of the execution engine lock even though we

   301   // can't actually acquire it at this time.

   302   assert(Thread::current()->is_VM_thread(), "must be called by VM thread");

   303   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

   304 

   305   SharkEntry *entry = (SharkEntry *) code;

   306   entry->context()->push_to_free_queue(entry->function());

   307 }

   308 

   309 void SharkCompiler::free_queued_methods() {

   310   // The free queue is protected by the execution engine lock

   311   assert(execution_engine_lock()->owned_by_self(), "should be");

   312 

   313   while (true) {

   314     Function *function = context()->pop_from_free_queue();

   315     if (function == NULL)

   316       break;

   317 

   318     execution_engine()->freeMachineCodeForFunction(function);

   319     function->eraseFromParent();

   320   }

   321 }

   322 

   323 const char* SharkCompiler::methodname(const char* klass, const char* method) {

   324   char *buf = NEW_RESOURCE_ARRAY(char, strlen(klass) + 2 + strlen(method) + 1);

   325 

   326   char *dst = buf;

   327   for (const char *c = klass; *c; c++) {

   328     if (*c == '/')

   329       *(dst++) = '.';

   330     else

   331       *(dst++) = *c;

   332   }

   333   *(dst++) = ':';

   334   *(dst++) = ':';

   335   for (const char *c = method; *c; c++) {

   336     *(dst++) = *c;

   337   }

   338   *(dst++) = '\0';

   339   return buf;

   340 }