--- old/src/share/vm/logging/logMessage.hpp	2016-02-16 16:50:51.385004234 +0100
+++ new/src/share/vm/logging/logMessage.hpp	2016-02-16 16:50:51.228338416 +0100
@@ -24,16 +24,10 @@
 #ifndef SHARE_VM_LOGGING_LOGMESSAGE_HPP
 #define SHARE_VM_LOGGING_LOGMESSAGE_HPP
 
+#include "precompiled.hpp"
 #include "logging/logDecorations.hpp"
 #include "logging/logLevel.hpp"
-#include "logging/logPrefix.hpp"
-#include "logging/logTagSet.hpp"
-#include "logging/logTag.hpp"
 #include "memory/allocation.hpp"
-#include "runtime/os.hpp"
-#include "runtime/thread.hpp"
-#include "utilities/debug.hpp"
-#include "utilities/ostream.hpp"
 
 // The LogMessage class represents a multi-part/multi-line message
 // that is guaranteed to be sent and written to the log outputs
@@ -73,6 +67,7 @@
   static const size_t InitialLineCapacity = 10;
   static const size_t InitialMessageBufferCapacity = 1024;
   bool _c_heap_allocated;
+  mutable bool _used;
 
   size_t _message_buffer_size;
   size_t _message_buffer_capacity;
@@ -86,20 +81,6 @@
 
   size_t (*_prefix_fn)(char*, size_t);
 
-  template <typename T>
-  void grow(T*& buffer, size_t& capacity, size_t minimum_length = 0) {
-    size_t new_size = capacity * 2;
-    if (new_size < minimum_length) {
-      new_size = minimum_length;
-    }
-    if (_c_heap_allocated) {
-      buffer = REALLOC_C_HEAP_ARRAY(T, buffer, new_size, mtLogging);
-    } else {
-      buffer = REALLOC_RESOURCE_ARRAY(T, buffer, capacity, new_size);
-    }
-    capacity = new_size;
-  }
-
   // Forbid copy assignment and copy constructor.
   void operator=(const LogMessage& ref) {}
   LogMessage(const LogMessage& ref) {}
@@ -146,37 +127,15 @@
     }
   };
 
-  LogMessage() : _message_buffer_size(0),
-                 _message_buffer_capacity(InitialMessageBufferCapacity),
-                 _line_count(0),
-                 _line_capacity(InitialLineCapacity),
-                 _c_heap_allocated(Thread::current_or_null() == NULL),
-                 _prefix_fn(NULL),
-                 _least_detailed_level(LogLevel::Off) {
-    if (_c_heap_allocated) {
-      _lines = NEW_C_HEAP_ARRAY(LogLine, _message_buffer_capacity, mtLogging);
-      _message_buffer = NEW_C_HEAP_ARRAY(char, InitialMessageBufferCapacity, mtLogging);
-    } else {
-      _lines = NEW_RESOURCE_ARRAY(LogLine, _message_buffer_capacity);
-      _message_buffer = NEW_RESOURCE_ARRAY(char, InitialMessageBufferCapacity);
-    }
-  }
-
-  ~LogMessage() {
-    if (_c_heap_allocated) {
-      FREE_C_HEAP_ARRAY(LogLine, _lines);
-      FREE_C_HEAP_ARRAY(char, _message_buffer);
-    } else {
-      FREE_RESOURCE_ARRAY(LogLine, _lines, _line_capacity);
-      FREE_RESOURCE_ARRAY(char, _message_buffer, _message_buffer_capacity);
-    }
-  }
+  LogMessage();
+  ~LogMessage();
 
   LogLevelType least_detailed_level() const {
     return _least_detailed_level;
   }
 
   Iterator iterator(LogLevelType level, LogDecorations& decorations) const {
+    _used = true;
     return Iterator(*this, level, decorations);
   }
 
@@ -191,68 +150,14 @@
   }
 
   ATTRIBUTE_PRINTF(3, 4)
-  void write(LogLevelType level, const char* fmt, ...) {
-    va_list args;
-    va_start(args, fmt);
-    vwrite(level, fmt, args);
-    va_end(args);
-  };
+  void write(LogLevelType level, const char* fmt, ...);
 
   ATTRIBUTE_PRINTF(3, 0)
-  void vwrite(LogLevelType level, const char* fmt, va_list args) {
-
-    if (level > _least_detailed_level) {
-      _least_detailed_level = level;
-    }
+  void vwrite(LogLevelType level, const char* fmt, va_list args);
 
-    size_t written;
-    for (int attempts = 0; attempts < 2; attempts++) {
-      written = 0;
-      size_t remaining_buffer_length = _message_buffer_capacity - _message_buffer_size;
-      char* current_buffer_position = _message_buffer + _message_buffer_size;
-      if (_prefix_fn != NULL) {
-        written += _prefix_fn(current_buffer_position, remaining_buffer_length);
-        current_buffer_position += written;
-        if (remaining_buffer_length < written) {
-          remaining_buffer_length = 0;
-        } else {
-          remaining_buffer_length -= written;
-        }
-      }
-      va_list copy;
-      va_copy(copy, args);
-      written += (size_t)os::log_vsnprintf(current_buffer_position, remaining_buffer_length, fmt, copy) + 1;
-      va_end(copy);
-      if (written > _message_buffer_capacity - _message_buffer_size) {
-        assert(attempts == 0, "Second attempt should always have a sufficiently large buffer (resized to fit).");
-        grow(_message_buffer, _message_buffer_capacity, _message_buffer_size + written);
-        continue;
-      }
-      break;
-    }
-
-    if (_line_count == _line_capacity) {
-      grow(_lines, _line_capacity);
-    }
-
-    _lines[_line_count].level = level;
-    _lines[_line_count].message_offset = _message_buffer_size;
-    _message_buffer_size += written;
-    _line_count++;
-  }
-
-#define LOG_LEVEL(level, name) ATTRIBUTE_PRINTF(2, 0) \
-  LogMessage& v##name(const char* fmt, va_list args) { \
-    vwrite(LogLevel::level, fmt, args); \
-    return *this; \
-  } \
-  LogMessage& name(const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3) { \
-    va_list args; \
-    va_start(args, fmt); \
-    vwrite(LogLevel::level, fmt, args); \
-    va_end(args); \
-    return *this; \
-  }
+#define LOG_LEVEL(level, name) \
+  LogMessage& v##name(const char* fmt, va_list args) ATTRIBUTE_PRINTF(2, 0); \
+  LogMessage& name(const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3);
   LOG_LEVEL_LIST
 #undef LOG_LEVEL
 };