1 /*
   2  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright 2008, 2009, 2010, 2011 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 "precompiled.hpp"
  27 #include "ci/ciEnv.hpp"
  28 #include "ci/ciMethod.hpp"
  29 #include "code/debugInfoRec.hpp"
  30 #include "code/dependencies.hpp"
  31 #include "code/exceptionHandlerTable.hpp"
  32 #include "code/oopRecorder.hpp"
  33 #include "compiler/abstractCompiler.hpp"
  34 #include "compiler/oopMap.hpp"
  35 #include "shark/llvmHeaders.hpp"
  36 #include "shark/sharkBuilder.hpp"
  37 #include "shark/sharkCodeBuffer.hpp"
  38 #include "shark/sharkCompiler.hpp"
  39 #include "shark/sharkContext.hpp"
  40 #include "shark/sharkEntry.hpp"
  41 #include "shark/sharkFunction.hpp"
  42 #include "shark/sharkMemoryManager.hpp"
  43 #include "shark/sharkNativeWrapper.hpp"
  44 #include "shark/shark_globals.hpp"
  45 #include "utilities/debug.hpp"
  46 
  47 #include <fnmatch.h>
  48 
  49 using namespace llvm;
  50 
  51 namespace {
  52   cl::opt<std::string>
  53   MCPU("mcpu");
  54 
  55   cl::list<std::string>
  56   MAttrs("mattr",
  57          cl::CommaSeparated);
  58 }
  59 
  60 SharkCompiler::SharkCompiler()
  61   : AbstractCompiler() {
  62   // Create the lock to protect the memory manager and execution engine
  63   _execution_engine_lock = new Monitor(Mutex::leaf, "SharkExecutionEngineLock");
  64   MutexLocker locker(execution_engine_lock());
  65 
  66   // Make LLVM safe for multithreading
  67   if (!llvm_start_multithreaded())
  68     fatal("llvm_start_multithreaded() failed");
  69 
  70   // Initialize the native target
  71   InitializeNativeTarget();
  72 
  73   // MCJIT require a native AsmPrinter
  74   InitializeNativeTargetAsmPrinter();
  75 
  76   // Create the two contexts which we'll use
  77   _normal_context = new SharkContext("normal");
  78   _native_context = new SharkContext("native");
  79 
  80   // Create the memory manager
  81   _memory_manager = new SharkMemoryManager();
  82 
  83   // Finetune LLVM for the current host CPU.
  84   StringMap<bool> Features;
  85   bool gotCpuFeatures = llvm::sys::getHostCPUFeatures(Features);
  86   std::string cpu("-mcpu=" + llvm::sys::getHostCPUName());
  87 
  88   std::vector<const char*> args;
  89   args.push_back(""); // program name
  90   args.push_back(cpu.c_str());
  91 
  92   std::string mattr("-mattr=");
  93   if(gotCpuFeatures){
  94     for(StringMap<bool>::iterator I = Features.begin(),
  95       E = Features.end(); I != E; ++I){
  96       if(I->second){
  97         std::string attr(I->first());
  98         mattr+="+"+attr+",";
  99       }
 100     }
 101     args.push_back(mattr.c_str());
 102   }
 103 
 104   args.push_back(0);  // terminator
 105   cl::ParseCommandLineOptions(args.size() - 1, (char **) &args[0]);
 106 
 107   // Create the JIT
 108   std::string ErrorMsg;
 109 
 110   EngineBuilder builder(_normal_context->module());
 111   builder.setMCPU(MCPU);
 112   builder.setMAttrs(MAttrs);
 113   builder.setJITMemoryManager(memory_manager());
 114   builder.setEngineKind(EngineKind::JIT);
 115   builder.setErrorStr(&ErrorMsg);
 116   if (! fnmatch(SharkOptimizationLevel, "None", 0)) {
 117     tty->print_cr("Shark optimization level set to: None");
 118     builder.setOptLevel(llvm::CodeGenOpt::None);
 119   } else if (! fnmatch(SharkOptimizationLevel, "Less", 0)) {
 120     tty->print_cr("Shark optimization level set to: Less");
 121     builder.setOptLevel(llvm::CodeGenOpt::Less);
 122   } else if (! fnmatch(SharkOptimizationLevel, "Aggressive", 0)) {
 123     tty->print_cr("Shark optimization level set to: Aggressive");
 124     builder.setOptLevel(llvm::CodeGenOpt::Aggressive);
 125   } // else Default is selected by, well, default :-)
 126   _execution_engine = builder.create();
 127 
 128   if (!execution_engine()) {
 129     if (!ErrorMsg.empty())
 130       printf("Error while creating Shark JIT: %s\n",ErrorMsg.c_str());
 131     else
 132       printf("Unknown error while creating Shark JIT\n");
 133     exit(1);
 134   }
 135 
 136   execution_engine()->addModule(
 137     _native_context->module());
 138 
 139   // All done
 140   mark_initialized();
 141 }
 142 
 143 void SharkCompiler::initialize() {
 144   ShouldNotCallThis();
 145 }
 146 
 147 void SharkCompiler::compile_method(ciEnv*    env,
 148                                    ciMethod* target,
 149                                    int       entry_bci) {
 150   assert(is_initialized(), "should be");
 151   ResourceMark rm;
 152   const char *name = methodname(
 153     target->holder()->name()->as_utf8(), target->name()->as_utf8());
 154 
 155   // Do the typeflow analysis
 156   ciTypeFlow *flow;
 157   if (entry_bci == InvocationEntryBci)
 158     flow = target->get_flow_analysis();
 159   else
 160     flow = target->get_osr_flow_analysis(entry_bci);
 161   if (flow->failing())
 162     return;
 163   if (SharkPrintTypeflowOf != NULL) {
 164     if (!fnmatch(SharkPrintTypeflowOf, name, 0))
 165       flow->print_on(tty);
 166   }
 167 
 168   // Create the recorders
 169   Arena arena;
 170   env->set_oop_recorder(new OopRecorder(&arena));
 171   OopMapSet oopmaps;
 172   env->set_debug_info(new DebugInformationRecorder(env->oop_recorder()));
 173   env->debug_info()->set_oopmaps(&oopmaps);
 174   env->set_dependencies(new Dependencies(env));
 175 
 176   // Create the code buffer and builder
 177   CodeBuffer hscb("Shark", 256 * K, 64 * K);
 178   hscb.initialize_oop_recorder(env->oop_recorder());
 179   MacroAssembler *masm = new MacroAssembler(&hscb);
 180   SharkCodeBuffer cb(masm);
 181   SharkBuilder builder(&cb);
 182 
 183   // Emit the entry point
 184   SharkEntry *entry = (SharkEntry *) cb.malloc(sizeof(SharkEntry));
 185 
 186   // Build the LLVM IR for the method
 187   Function *function = SharkFunction::build(env, &builder, flow, name);
 188 
 189   // Generate native code.  It's unpleasant that we have to drop into
 190   // the VM to do this -- it blocks safepoints -- but I can't see any
 191   // other way to handle the locking.
 192   {
 193     ThreadInVMfromNative tiv(JavaThread::current());
 194     generate_native_code(entry, function, name);
 195   }
 196 
 197   // Install the method into the VM
 198   CodeOffsets offsets;
 199   offsets.set_value(CodeOffsets::Deopt, 0);
 200   offsets.set_value(CodeOffsets::Exceptions, 0);
 201   offsets.set_value(CodeOffsets::Verified_Entry,
 202                     target->is_static() ? 0 : wordSize);
 203 
 204   ExceptionHandlerTable handler_table;
 205   ImplicitExceptionTable inc_table;
 206 
 207   env->register_method(target,
 208                        entry_bci,
 209                        &offsets,
 210                        0,
 211                        &hscb,
 212                        0,
 213                        &oopmaps,
 214                        &handler_table,
 215                        &inc_table,
 216                        this,
 217                        env->comp_level(),
 218                        false,
 219                        false);
 220 }
 221 
 222 nmethod* SharkCompiler::generate_native_wrapper(MacroAssembler* masm,
 223                                                 methodHandle    target,
 224                                                 int             compile_id,
 225                                                 BasicType*      arg_types,
 226                                                 BasicType       return_type) {
 227   assert(is_initialized(), "should be");
 228   ResourceMark rm;
 229   const char *name = methodname(
 230     target->klass_name()->as_utf8(), target->name()->as_utf8());
 231 
 232   // Create the code buffer and builder
 233   SharkCodeBuffer cb(masm);
 234   SharkBuilder builder(&cb);
 235 
 236   // Emit the entry point
 237   SharkEntry *entry = (SharkEntry *) cb.malloc(sizeof(SharkEntry));
 238 
 239   // Build the LLVM IR for the method
 240   SharkNativeWrapper *wrapper = SharkNativeWrapper::build(
 241     &builder, target, name, arg_types, return_type);
 242 
 243   // Generate native code
 244   generate_native_code(entry, wrapper->function(), name);
 245 
 246   // Return the nmethod for installation in the VM
 247   return nmethod::new_native_nmethod(target,
 248                                      compile_id,
 249                                      masm->code(),
 250                                      0,
 251                                      0,
 252                                      wrapper->frame_size(),
 253                                      wrapper->receiver_offset(),
 254                                      wrapper->lock_offset(),
 255                                      wrapper->oop_maps());
 256 }
 257 
 258 void SharkCompiler::generate_native_code(SharkEntry* entry,
 259                                          Function*   function,
 260                                          const char* name) {
 261   // Print the LLVM bitcode, if requested
 262   if (SharkPrintBitcodeOf != NULL) {
 263     if (!fnmatch(SharkPrintBitcodeOf, name, 0))
 264       function->dump();
 265   }
 266 
 267   if (SharkVerifyFunction != NULL) {
 268     if (!fnmatch(SharkVerifyFunction, name, 0)) {
 269       verifyFunction(*function);
 270     }
 271   }
 272 
 273   // Compile to native code
 274   address code = NULL;
 275   context()->add_function(function);
 276   {
 277     MutexLocker locker(execution_engine_lock());
 278     free_queued_methods();
 279 
 280 #ifndef NDEBUG
 281 #if SHARK_LLVM_VERSION <= 31
 282 #define setCurrentDebugType SetCurrentDebugType
 283 #endif
 284     if (SharkPrintAsmOf != NULL) {
 285       if (!fnmatch(SharkPrintAsmOf, name, 0)) {
 286         llvm::setCurrentDebugType(X86_ONLY("x86-emitter") NOT_X86("jit"));
 287         llvm::DebugFlag = true;
 288       }
 289       else {
 290         llvm::setCurrentDebugType("");
 291         llvm::DebugFlag = false;
 292       }
 293     }
 294 #ifdef setCurrentDebugType
 295 #undef setCurrentDebugType
 296 #endif
 297 #endif // !NDEBUG
 298     memory_manager()->set_entry_for_function(function, entry);
 299     code = (address) execution_engine()->getPointerToFunction(function);
 300   }
 301   assert(code != NULL, "code must be != NULL");
 302   entry->set_entry_point(code);
 303   entry->set_function(function);
 304   entry->set_context(context());
 305   address code_start = entry->code_start();
 306   address code_limit = entry->code_limit();
 307 
 308   // Register generated code for profiling, etc
 309   if (JvmtiExport::should_post_dynamic_code_generated())
 310     JvmtiExport::post_dynamic_code_generated(name, code_start, code_limit);
 311 
 312   // Print debug information, if requested
 313   if (SharkTraceInstalls) {
 314     tty->print_cr(
 315       " [%p-%p): %s (%d bytes code)",
 316       code_start, code_limit, name, code_limit - code_start);
 317   }
 318 }
 319 
 320 void SharkCompiler::free_compiled_method(address code) {
 321   // This method may only be called when the VM is at a safepoint.
 322   // All _thread_in_vm threads will be waiting for the safepoint to
 323   // finish with the exception of the VM thread, so we can consider
 324   // ourself the owner of the execution engine lock even though we
 325   // can't actually acquire it at this time.
 326   assert(Thread::current()->is_Compiler_thread(), "must be called by compiler thread");
 327   assert_locked_or_safepoint(CodeCache_lock);
 328 
 329   SharkEntry *entry = (SharkEntry *) code;
 330   entry->context()->push_to_free_queue(entry->function());
 331 }
 332 
 333 void SharkCompiler::free_queued_methods() {
 334   // The free queue is protected by the execution engine lock
 335   assert(execution_engine_lock()->owned_by_self(), "should be");
 336 
 337   while (true) {
 338     Function *function = context()->pop_from_free_queue();
 339     if (function == NULL)
 340       break;
 341 
 342     execution_engine()->freeMachineCodeForFunction(function);
 343     function->eraseFromParent();
 344   }
 345 }
 346 
 347 const char* SharkCompiler::methodname(const char* klass, const char* method) {
 348   char *buf = NEW_RESOURCE_ARRAY(char, strlen(klass) + 2 + strlen(method) + 1);
 349 
 350   char *dst = buf;
 351   for (const char *c = klass; *c; c++) {
 352     if (*c == '/')
 353       *(dst++) = '.';
 354     else
 355       *(dst++) = *c;
 356   }
 357   *(dst++) = ':';
 358   *(dst++) = ':';
 359   for (const char *c = method; *c; c++) {
 360     *(dst++) = *c;
 361   }
 362   *(dst++) = '\0';
 363   return buf;
 364 }