diff a/src/hotspot/share/code/codeBlob.hpp b/src/hotspot/share/code/codeBlob.hpp
--- a/src/hotspot/share/code/codeBlob.hpp
+++ b/src/hotspot/share/code/codeBlob.hpp
@@ -56,10 +56,11 @@
 //  RuntimeBlob          : Non-compiled method code; generated glue code
 //   BufferBlob          : Used for non-relocatable code such as interpreter, stubroutines, etc.
 //    AdapterBlob        : Used to hold C2I/I2C adapters
 //    VtableBlob         : Used for holding vtable chunks
 //    MethodHandlesAdapterBlob : Used to hold MethodHandles adapters
+//    BufferedInlineTypeBlob   : used for pack/unpack handlers
 //   RuntimeStub         : Call to VM runtime methods
 //   SingletonBlob       : Super-class for all blobs that exist in only one instance
 //    DeoptimizationBlob : Used for deoptimization
 //    ExceptionBlob      : Used for stack unrolling
 //    SafepointBlob      : Used to handle illegal instruction exceptions
@@ -79,10 +80,11 @@
   Nmethod,
   Buffer,
   Adapter,
   Vtable,
   MH_Adapter,
+  BufferedInlineType,
   Runtime_Stub,
   Deoptimization,
   Exception,
   Safepoint,
   Uncommon_Trap,
@@ -159,10 +161,11 @@
   bool is_exception_stub() const              { return _kind == CodeBlobKind::Exception; }
   bool is_safepoint_stub() const              { return _kind == CodeBlobKind::Safepoint; }
   bool is_adapter_blob() const                { return _kind == CodeBlobKind::Adapter; }
   bool is_vtable_blob() const                 { return _kind == CodeBlobKind::Vtable; }
   bool is_method_handles_adapter_blob() const { return _kind == CodeBlobKind::MH_Adapter; }
+  bool is_buffered_inline_type_blob() const   { return _kind == CodeBlobKind::BufferedInlineType; }
   bool is_upcall_stub() const                 { return _kind == CodeBlobKind::Upcall; }
 
   // Casting
   nmethod* as_nmethod_or_null()               { return is_nmethod() ? (nmethod*) this : nullptr; }
   nmethod* as_nmethod()                       { assert(is_nmethod(), "must be nmethod"); return (nmethod*) this; }
@@ -300,17 +303,19 @@
 class BufferBlob: public RuntimeBlob {
   friend class VMStructs;
   friend class AdapterBlob;
   friend class VtableBlob;
   friend class MethodHandlesAdapterBlob;
+  friend class BufferedInlineTypeBlob;
   friend class UpcallStub;
   friend class WhiteBox;
 
  private:
   // Creation support
   BufferBlob(const char* name, CodeBlobKind kind, int size);
-  BufferBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size);
+  BufferBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size, int header_size);
+  BufferBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size, int frame_complete, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments = false);
 
   void* operator new(size_t s, unsigned size) throw();
 
  public:
   // Creation
@@ -330,15 +335,21 @@
 //----------------------------------------------------------------------------------------------------
 // AdapterBlob: used to hold C2I/I2C adapters
 
 class AdapterBlob: public BufferBlob {
 private:
-  AdapterBlob(int size, CodeBuffer* cb);
+  AdapterBlob(int size, CodeBuffer* cb, int frame_complete, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments = false);
 
 public:
   // Creation
-  static AdapterBlob* create(CodeBuffer* cb);
+  static AdapterBlob* create(CodeBuffer* cb,
+                             int frame_complete,
+                             int frame_size,
+                             OopMapSet* oop_maps,
+                             bool caller_must_gc_arguments = false);
+
+  bool caller_must_gc_arguments(JavaThread* thread) const { return true; }
 };
 
 //---------------------------------------------------------------------------------------------------
 class VtableBlob: public BufferBlob {
 private:
@@ -361,10 +372,29 @@
 public:
   // Creation
   static MethodHandlesAdapterBlob* create(int buffer_size);
 };
 
+//----------------------------------------------------------------------------------------------------
+// BufferedInlineTypeBlob : used for pack/unpack handlers
+
+class BufferedInlineTypeBlob: public BufferBlob {
+private:
+  const int _pack_fields_off;
+  const int _pack_fields_jobject_off;
+  const int _unpack_fields_off;
+
+  BufferedInlineTypeBlob(int size, CodeBuffer* cb, int pack_fields_off, int pack_fields_jobject_off, int unpack_fields_off);
+
+public:
+  // Creation
+  static BufferedInlineTypeBlob* create(CodeBuffer* cb, int pack_fields_off, int pack_fields_jobject_off, int unpack_fields_off);
+
+  address pack_fields() const { return code_begin() + _pack_fields_off; }
+  address pack_fields_jobject() const { return code_begin() + _pack_fields_jobject_off; }
+  address unpack_fields() const { return code_begin() + _unpack_fields_off; }
+};
 
 //----------------------------------------------------------------------------------------------------
 // RuntimeStub: describes stubs used by compiled code to call a (static) C++ runtime routine
 
 class RuntimeStub: public RuntimeBlob {
