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 }