diff --git a/tools/profile.mjs b/tools/profile.mjs
index 834bdec251..5aadeb8a9d 100644
--- a/tools/profile.mjs
+++ b/tools/profile.mjs
@@ -190,6 +190,21 @@ export class Profile {
     throw new Error(`unknown code state: ${s}`);
   }
 
+  static getKindFromState(state) {
+    if (state === this.CodeState.COMPILED) {
+      return "Builtin";
+    } else if (state === this.CodeState.IGNITION) {
+      return "Unopt";
+    } else if (state === this.CodeState.NATIVE_CONTEXT_INDEPENDENT) {
+      return "NCI";
+    } else if (state === this.CodeState.TURBOPROP) {
+      return "Turboprop";
+    } else if (state === this.CodeState.TURBOFAN) {
+      return "Opt";
+    }
+    throw new Error(`unknown code state: ${state}`);
+  }
+
   /**
    * Called whenever the specified operation has failed finding a function
    * containing the specified address. Should be overriden by subclasses.
@@ -1072,13 +1087,7 @@ JsonProfile.prototype.addFuncCode = function (
 
     this.functionEntries_[func.funcId].codes.push(entry.codeId);
 
-    if (state === 0) {
-      kind = "Builtin";
-    } else if (state === 1) {
-      kind = "Unopt";
-    } else if (state === 2) {
-      kind = "Opt";
-    }
+    kind = Profile.getKindFromState(state);
 
     this.codeEntries_.push({
       name: entry.name,
diff --git a/tools/profview/profile-utils.js b/tools/profview/profile-utils.js
index 4be55893dd..9007855ea9 100644
--- a/tools/profview/profile-utils.js
+++ b/tools/profview/profile-utils.js
@@ -19,7 +19,9 @@ let codeKinds = [
     "BUILTIN",
     "REGEXP",
     "JSOPT",
-    "JSUNOPT"
+    "JSUNOPT",
+    "JSNCI",
+    "JSTURBOPROP"
 ];
 
 function resolveCodeKind(code) {
@@ -55,6 +57,10 @@ function resolveCodeKind(code) {
       return "JSOPT";
     } else if (code.kind === "Unopt") {
       return "JSUNOPT";
+    } else if (code.kind === "NCI") {
+      return "JSNCI";
+    } else if (code.kind === "Turboprop") {
+      return "JSTURBOPROP";
     }
   }
   console.log("Unknown code type '" + type + "'.");
@@ -264,6 +270,8 @@ function buildCategoryTreeAndLookup() {
     root.children.push(n);
   }
   addCategory("JS Optimized", [ "JSOPT" ]);
+  addCategory("JS NCI", [ "JSNCI" ]);
+  addCategory("JS Turboprop", [ "JSTURBOPROP" ]);
   addCategory("JS Unoptimized", [ "JSUNOPT", "BC" ]);
   addCategory("IC", [ "IC" ]);
   addCategory("RegExp", [ "REGEXP" ]);
@@ -526,11 +534,15 @@ function computeOptimizationStats(file,
 
   let functionCount = 0;
   let optimizedFunctionCount = 0;
+  let turbopropOptimizedFunctionCount = 0;
   let deoptimizedFunctionCount = 0;
   let optimizations = newCollection();
+  let turbopropOptimizations = newCollection();
   let eagerDeoptimizations = newCollection();
   let softDeoptimizations = newCollection();
   let lazyDeoptimizations = newCollection();
+  let softBailouts = newCollection();
+  let eagerBailouts = newCollection();
 
   for (let i = 0; i < file.functions.length; i++) {
     let f = file.functions[i];
@@ -541,6 +553,7 @@ function computeOptimizationStats(file,
 
     functionCount++;
     let optimized = false;
+    let turboprop_optimized = false;
     let deoptimized = false;
 
     for (let j = 0; j < f.codes.length; j++) {
@@ -552,19 +565,33 @@ function computeOptimizationStats(file,
           addToCollection(optimizations, code);
         }
       }
+      if (code.kind === "Turboprop") {
+        turboprop_optimized = true;
+        if (code.tm >= timeStart && code.tm <= timeEnd) {
+          addToCollection(turbopropOptimizations, code);
+        }
+      }
       if (code.deopt) {
-        deoptimized = true;
+        if (code.deopt.bailoutType === "deopt-lazy" || code.deopt.bailoutType === "deopt-eager" || code.deopt.bailoutType === "deopt-lazy") {
+          deoptimized = true;
+        }
         if (code.deopt.tm >= timeStart && code.deopt.tm <= timeEnd) {
           switch (code.deopt.bailoutType) {
-            case "lazy":
+            case "deopt-lazy":
               addToCollection(lazyDeoptimizations, code);
               break;
-            case "eager":
+            case "deopt-eager":
               addToCollection(eagerDeoptimizations, code);
               break;
-            case "soft":
+            case "deopt-soft":
               addToCollection(softDeoptimizations, code);
               break;
+            case "bailout-soft":
+              addToCollection(softBailouts, code);
+              break;
+            case "bailout":
+              addToCollection(eagerBailouts, code);
+              break;
           }
         }
       }
@@ -572,6 +599,9 @@ function computeOptimizationStats(file,
     if (optimized) {
       optimizedFunctionCount++;
     }
+    if (turboprop_optimized) {
+      turbopropOptimizedFunctionCount++;
+    }
     if (deoptimized) {
       deoptimizedFunctionCount++;
     }
@@ -586,15 +616,20 @@ function computeOptimizationStats(file,
   sortCollection(lazyDeoptimizations);
   sortCollection(softDeoptimizations);
   sortCollection(optimizations);
+  sortCollection(turbopropOptimizations);
 
   return {
     functionCount,
     optimizedFunctionCount,
+    turbopropOptimizedFunctionCount,
     deoptimizedFunctionCount,
     optimizations,
+    turbopropOptimizations,
     eagerDeoptimizations,
     lazyDeoptimizations,
     softDeoptimizations,
+    softBailouts,
+    eagerBailouts,
   };
 }
 
diff --git a/tools/profview/profview.js b/tools/profview/profview.js
index 210cec7618..248146f99f 100644
--- a/tools/profview/profview.js
+++ b/tools/profview/profview.js
@@ -216,6 +216,14 @@ const bucketDescriptors =
         color : "#64dd17",
         backgroundColor : "#80e27e",
         text : "JS Optimized" },
+      { kinds : [ "JSNCI" ],
+        color : "#3289a8",
+        backgroundColor : "#3289a8",
+        text : "JS NCI" },
+      { kinds : [ "JSTURBOPROP" ],
+        color : "#693eb8",
+        backgroundColor : "#a6c452",
+        text : "JS Turboprop" },
       { kinds : [ "JSUNOPT", "BC" ],
         color : "#dd2c00",
         backgroundColor : "#ff9e80",
@@ -308,6 +316,10 @@ function codeTypeToText(type) {
       return "RegExp";
     case "JSOPT":
       return "JS opt";
+    case "JSNCI":
+      return "JS NCI";
+    case "JSTURBOPROP":
+      return "JS Turboprop";
     case "JSUNOPT":
       return "JS unopt";
   }
@@ -1275,15 +1287,27 @@ class SummaryView {
 
     addRow("Total function count:", stats.functionCount);
     addRow("Optimized function count:", stats.optimizedFunctionCount, 1);
+    if (stats.turbopropOptimizedFunctionCount != 0) {
+      addRow("Turboprop optimized function count:", stats.turbopropOptimizedFunctionCount, 1);
+    }
     addRow("Deoptimized function count:", stats.deoptimizedFunctionCount, 2);
 
     addExpandableRow("Optimization count:", stats.optimizations, 0, "opt");
+    if (stats.turbopropOptimizedFunctionCount != 0) {
+      addExpandableRow("Turboprop Optimization count:", stats.turbopropOptimizations, 0, "tp");
+    }
     let deoptCount = stats.eagerDeoptimizations.count +
         stats.softDeoptimizations.count + stats.lazyDeoptimizations.count;
     addRow("Deoptimization count:", deoptCount);
     addExpandableRow("Eager:", stats.eagerDeoptimizations, 1, "eager");
     addExpandableRow("Lazy:", stats.lazyDeoptimizations, 1, "lazy");
     addExpandableRow("Soft:", stats.softDeoptimizations, 1, "soft");
+    if (stats.softBailouts.count != 0) {
+      addExpandableRow("SoftBailout:", stats.softBailouts, 1, "softbailout");
+    }
+    if (stats.eagerBailouts.count != 0) {
+      addExpandableRow("EagerBailout:", stats.eagerBailouts, 1, "eagerbailout");
+    }
 
     table.appendChild(rows);
     this.element.appendChild(table);
@@ -1369,6 +1393,7 @@ class SourceData {
     for (let i = 0; i < file.scripts.length; i++) {
       const scriptBlock = file.scripts[i];
       if (scriptBlock === null) continue; // Array may be sparse.
+      if (scriptBlock.source === undefined) continue;
       let source = scriptBlock.source.split("\n");
       this.scripts.set(i, source);
     }