Refactor slicer to not have top-level header exports am: dc7eb39f96 am: bb6b646dafandroid-9.0.0_r47android-9.0.0_r46android-9.0.0_r45android-9.0.0_r44android-9.0.0_r43android-9.0.0_r42android-9.0.0_r41android-9.0.0_r40android-9.0.0_r39android-9.0.0_r38android-9.0.0_r37android-9.0.0_r36android-9.0.0_r35android-9.0.0_r34android-9.0.0_r33android-9.0.0_r32android-9.0.0_r31android-9.0.0_r30android-9.0.0_r22android-9.0.0_r21android-9.0.0_r20android-9.0.0_r19android-9.0.0_r16android-9.0.0_r12android-9.0.0_r11pie-qpr3-s1-releasepie-qpr3-releasepie-qpr3-b-releasepie-qpr2-releasepie-qpr1-s3-releasepie-qpr1-s2-releasepie-qpr1-s1-releasepie-qpr1-releasepie-dr1-releasepie-dr1-devpie-devpie-b4s4-releasepie-b4s4-dev

am: 143381a62d

Change-Id: I4f6f3c6b52d84079c5410495cbd0cc859a2d5ba1

42 files changed, 413 insertions, 416 deletions

diff --git a/dexter/Android.bp b/dexter/Android.bp
index db4654b..6d1e9f8 100644
--- a/dexter/Android.bp
+++ b/dexter/Android.bp
@@ -13,8 +13,6 @@ cc_binary {
     rtti: true,
     host_supported: true,
     device_supported: true,
-    // TODO move includes so this isn't needed.
-    include_dirs: ["tools/dexter"],
     cflags: [
         "-Wall",
         "-Werror",
diff --git a/dexter/dexter.cc b/dexter/dexter.cc
index 75bb8d8..7943314 100644
--- a/dexter/dexter.cc
+++ b/dexter/dexter.cc
@@ -283,7 +283,7 @@ bool Dexter::CreateNewImage(std::shared_ptr<ir::DexFile> dex_ir) {
     return false;
   }
 
-  SCOPE_EXIT {
+  SLICER_SCOPE_EXIT {
     allocator.Free(new_image);
   };
 
@@ -300,12 +300,12 @@ bool Dexter::CreateNewImage(std::shared_ptr<ir::DexFile> dex_ir) {
       return false;
     }
 
-    SCOPE_EXIT {
+    SLICER_SCOPE_EXIT {
       fclose(out_file);
     };
 
     // write the new image
-    CHECK(fwrite(new_image, 1, new_image_size, out_file) == new_image_size);
+    SLICER_CHECK(fwrite(new_image, 1, new_image_size, out_file) == new_image_size);
   }
 
   return true;
@@ -324,7 +324,7 @@ int Dexter::ProcessDex() {
     return 1;
   }
 
-  SCOPE_EXIT {
+  SLICER_SCOPE_EXIT {
     fclose(in_file);
   };
 
@@ -337,7 +337,7 @@ int Dexter::ProcessDex() {
 
   // read input .dex file
   fseek(in_file, 0, SEEK_SET);
-  CHECK(fread(in_buff.get(), 1, in_size, in_file) == in_size);
+  SLICER_CHECK(fread(in_buff.get(), 1, in_size, in_file) == in_size);
 
   // initialize the .dex reader
   dex::Reader reader(in_buff.get(), in_size);
diff --git a/dexter/dissasembler.cc b/dexter/dissasembler.cc
index e2edffe..1f44ee1 100644
--- a/dexter/dissasembler.cc
+++ b/dexter/dissasembler.cc
@@ -195,21 +195,21 @@ bool PrintCodeIrVisitor::Visit(lir::String* string) {
 }
 
 bool PrintCodeIrVisitor::Visit(lir::Type* type) {
-  CHECK(type->index != dex::kNoIndex);
+  SLICER_CHECK(type->index != dex::kNoIndex);
   auto ir_type = type->ir_type;
   printf("%s", ir_type->Decl().c_str());
   return true;
 }
 
 bool PrintCodeIrVisitor::Visit(lir::Field* field) {
-  CHECK(field->index != dex::kNoIndex);
+  SLICER_CHECK(field->index != dex::kNoIndex);
   auto ir_field = field->ir_field;
   printf("%s.%s", ir_field->parent->Decl().c_str(), ir_field->name->c_str());
   return true;
 }
 
 bool PrintCodeIrVisitor::Visit(lir::Method* method) {
-  CHECK(method->index != dex::kNoIndex);
+  SLICER_CHECK(method->index != dex::kNoIndex);
   auto ir_method = method->ir_method;
   printf("%s.%s%s",
          ir_method->parent->Decl().c_str(),
diff --git a/dexter/experimental.cc b/dexter/experimental.cc
index 5f9c14b..8e5e6ad 100644
--- a/dexter/experimental.cc
+++ b/dexter/experimental.cc
@@ -236,22 +236,22 @@ void StressExitHook(std::shared_ptr<ir::DexFile> dex_ir) {
 
       switch (bytecode->opcode) {
         case dex::OP_RETURN_VOID:
-          CHECK(return_void);
+          SLICER_CHECK(return_void);
           break;
         case dex::OP_RETURN:
-          CHECK(!return_void);
+          SLICER_CHECK(!return_void);
           move_result_opcode = dex::OP_MOVE_RESULT;
           reg = bytecode->CastOperand<lir::VReg>(0)->reg;
           reg_count = 1;
           break;
         case dex::OP_RETURN_OBJECT:
-          CHECK(!return_void);
+          SLICER_CHECK(!return_void);
           move_result_opcode = dex::OP_MOVE_RESULT_OBJECT;
           reg = bytecode->CastOperand<lir::VReg>(0)->reg;
           reg_count = 1;
           break;
         case dex::OP_RETURN_WIDE:
-          CHECK(!return_void);
+          SLICER_CHECK(!return_void);
           move_result_opcode = dex::OP_MOVE_RESULT_WIDE;
           reg = bytecode->CastOperand<lir::VRegPair>(0)->base_reg;
           reg_count = 2;
@@ -299,10 +299,10 @@ void TestMethodInstrumenter(std::shared_ptr<ir::DexFile> dex_ir) {
       ir::MethodId("LTracer;", "wrapFoo"))  ;
 
   auto method1 = ir::MethodId("LTarget;", "foo", "(ILjava/lang/String;)I");
-  CHECK(mi.InstrumentMethod(method1));
+  SLICER_CHECK(mi.InstrumentMethod(method1));
 
   auto method2 = ir::MethodId("LTarget;", "foo", "(I[[Ljava/lang/String;)Ljava/lang/Integer;");
-  CHECK(mi.InstrumentMethod(method2));
+  SLICER_CHECK(mi.InstrumentMethod(method2));
 }
 
 // Stress scratch register allocation
@@ -318,11 +318,11 @@ void StressScratchRegs(std::shared_ptr<ir::DexFile> dex_ir) {
   // apply the transformations to every single method
   for (auto& ir_method : dex_ir->encoded_methods) {
     if (ir_method->code != nullptr) {
-      CHECK(mi.InstrumentMethod(ir_method.get()));
-      CHECK(t1->ScratchRegs().size() == 1);
-      CHECK(t2->ScratchRegs().size() == 1);
-      CHECK(t3->ScratchRegs().size() == 1);
-      CHECK(t4->ScratchRegs().size() == 20);
+      SLICER_CHECK(mi.InstrumentMethod(ir_method.get()));
+      SLICER_CHECK(t1->ScratchRegs().size() == 1);
+      SLICER_CHECK(t2->ScratchRegs().size() == 1);
+      SLICER_CHECK(t3->ScratchRegs().size() == 1);
+      SLICER_CHECK(t4->ScratchRegs().size() == 20);
     }
   }
 }
@@ -401,7 +401,7 @@ void CodeCoverage(std::shared_ptr<ir::DexFile> dex_ir) {
           break;
         }
       }
-      CHECK(trace_point != nullptr);
+      SLICER_CHECK(trace_point != nullptr);
 
       // special case: don't separate 'move-result-<kind>' from the preceding invoke
       auto opcode = static_cast<lir::Bytecode*>(trace_point)->opcode;
@@ -442,7 +442,7 @@ void StressFindMethod(std::shared_ptr<ir::DexFile> dex_ir) {
     auto signature = decl->prototype->Signature();
     auto class_descriptor = decl->parent->descriptor;
     ir::MethodId method_id(class_descriptor->c_str(), decl->name->c_str(), signature.c_str());
-    CHECK(builder.FindMethod(method_id) == ir_method.get());
+    SLICER_CHECK(builder.FindMethod(method_id) == ir_method.get());
     ++method_count;
   }
   printf("Everything looks fine, found %d methods.\n", method_count);
@@ -474,7 +474,7 @@ void RegsHistogram(std::shared_ptr<ir::DexFile> dex_ir) {
     if (ir_method->code != nullptr) {
       const int regs = ir_method->code->registers;
       const int ins =  ir_method->code->ins_count;
-      CHECK(regs >= ins);
+      SLICER_CHECK(regs >= ins);
       regs_histogram[regs]++;
       param_histogram[ins]++;
       extra_histogram[regs - ins]++;
diff --git a/slicer/Android.bp b/slicer/Android.bp
index 5a154f3..075b896 100644
--- a/slicer/Android.bp
+++ b/slicer/Android.bp
@@ -16,8 +16,7 @@ cc_defaults {
         "tryblocks_encoder.cc",
         "writer.cc",
     ],
-    // TODO Move includes around so we don't need to have include_dirs in users.
-    export_include_dirs: ["."],
+    export_include_dirs: ["export"],
     device_supported: true,
     shared_libs: ["libz"],
     rtti: true,
diff --git a/slicer/bytecode_encoder.cc b/slicer/bytecode_encoder.cc
index c1659a9..f4caae4 100644
--- a/slicer/bytecode_encoder.cc
+++ b/slicer/bytecode_encoder.cc
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "bytecode_encoder.h"
-#include "common.h"
-#include "chronometer.h"
+#include "slicer/bytecode_encoder.h"
+#include "slicer/common.h"
+#include "slicer/chronometer.h"
 
 #include <assert.h>
 
@@ -25,68 +25,68 @@ namespace lir {
 // Pack a 16bit word: 00AA
 static dex::u2 Pack_Z_8(dex::u4 a) {
   dex::u2 fa = (a & 0xff);
-  CHECK(fa == a);
+  SLICER_CHECK(fa == a);
   return fa;
 }
 
 // Pack a 16bit word: AABB
 static dex::u2 Pack_8_8(dex::u4 a, dex::u4 b) {
   dex::u2 fa = (a & 0xff);
-  CHECK(fa == a);
+  SLICER_CHECK(fa == a);
   dex::u2 fb = (b & 0xff);
-  CHECK(fb == b);
+  SLICER_CHECK(fb == b);
   return (fa << 8) | fb;
 }
 
 // Pack a 16bit word: ABCC
 static dex::u2 Pack_4_4_8(dex::u4 a, dex::u4 b, dex::u4 c) {
   dex::u2 fa = (a & 0xf);
-  CHECK(fa == a);
+  SLICER_CHECK(fa == a);
   dex::u2 fb = (b & 0xf);
-  CHECK(fb == b);
+  SLICER_CHECK(fb == b);
   dex::u2 fc = (c & 0xff);
-  CHECK(fc == c);
+  SLICER_CHECK(fc == c);
   return (fa << 12) | (fb << 8) | fc;
 }
 
 // Pack a 16bit word: ABCD
 static dex::u2 Pack_4_4_4_4(dex::u4 a, dex::u4 b, dex::u4 c, dex::u4 d) {
   dex::u2 fa = (a & 0xf);
-  CHECK(fa == a);
+  SLICER_CHECK(fa == a);
   dex::u2 fb = (b & 0xf);
-  CHECK(fb == b);
+  SLICER_CHECK(fb == b);
   dex::u2 fc = (c & 0xf);
-  CHECK(fc == c);
+  SLICER_CHECK(fc == c);
   dex::u2 fd = (d & 0xf);
-  CHECK(fd == d);
+  SLICER_CHECK(fd == d);
   return (fa << 12) | (fb << 8) | (fc << 4) | fd;
 }
 
 // Pack a 16bit word: AAAA
 static dex::u2 Pack_16(dex::u4 a) {
   dex::u2 fa = (a & 0xffff);
-  CHECK(fa == a);
+  SLICER_CHECK(fa == a);
   return fa;
 }
 
 // Trim a 4bit signed integer, making sure we're not discarding significant bits
 static dex::u4 Trim_S0(dex::u4 value) {
   dex::u4 trim = value & 0xf;
-  CHECK(dex::u4(dex::s4(trim << 28) >> 28) == value);
+  SLICER_CHECK(dex::u4(dex::s4(trim << 28) >> 28) == value);
   return trim;
 }
 
 // Trim a 8bit signed integer, making sure we're not discarding significant bits
 static dex::u4 Trim_S1(dex::u4 value) {
   dex::u4 trim = value & 0xff;
-  CHECK(dex::u4(dex::s4(trim << 24) >> 24) == value);
+  SLICER_CHECK(dex::u4(dex::s4(trim << 24) >> 24) == value);
   return trim;
 }
 
 // Trim a 16bit signed integer, making sure we're not discarding significant bits
 static dex::u4 Trim_S2(dex::u4 value) {
   dex::u4 trim = value & 0xffff;
-  CHECK(dex::u4(dex::s4(trim << 16) >> 16) == value);
+  SLICER_CHECK(dex::u4(dex::s4(trim << 16) >> 16) == value);
   return trim;
 }
 
@@ -139,13 +139,13 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
   switch (format) {
     case dex::kFmt10x:  // op
     {
-      CHECK(bytecode->operands.size() == 0);
+      SLICER_CHECK(bytecode->operands.size() == 0);
       bytecode_.Push<dex::u2>(Pack_Z_8(opcode));
     } break;
 
     case dex::kFmt12x:  // op vA, vB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       bytecode_.Push<dex::u2>(Pack_4_4_8(vB, vA, opcode));
@@ -153,7 +153,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt22x:  // op vAA, vBBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
@@ -162,7 +162,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt32x:  // op vAAAA, vBBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       bytecode_.Push<dex::u2>(Pack_Z_8(opcode));
@@ -172,7 +172,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt11n:  // op vA, #+B
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 B = Trim_S0(bytecode->CastOperand<Const32>(1)->u.u4_value);
       bytecode_.Push<dex::u2>(Pack_4_4_8(B, vA, opcode));
@@ -180,7 +180,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt21s:  // op vAA, #+BBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 B = Trim_S2(bytecode->CastOperand<Const32>(1)->u.u4_value);
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
@@ -189,14 +189,14 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt11x:  // op vAA
     {
-      CHECK(bytecode->operands.size() == 1);
+      SLICER_CHECK(bytecode->operands.size() == 1);
       dex::u4 vA = GetRegA(bytecode, 0);
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
     } break;
 
     case dex::kFmt31i:  // op vAA, #+BBBBBBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 B = bytecode->CastOperand<Const32>(1)->u.u4_value;
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
@@ -206,14 +206,14 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt20t:  // op +AAAA
     {
-      CHECK(bytecode->operands.size() == 1);
+      SLICER_CHECK(bytecode->operands.size() == 1);
       auto label = bytecode->CastOperand<CodeLocation>(0)->label;
       dex::u4 A = 0;
       if (label->offset != kInvalidOffset) {
         assert(label->offset <= offset_);
         A = label->offset - offset_;
-        CHECK(A != 0);
-        CHECK((A >> 16) == 0xffff);  // TODO: out of range!
+        SLICER_CHECK(A != 0);
+        SLICER_CHECK((A >> 16) == 0xffff);  // TODO: out of range!
       } else {
         fixups_.push_back(LabelFixup(offset_, label, true));
       }
@@ -223,7 +223,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt30t:  // op +AAAAAAAA
     {
-      CHECK(bytecode->operands.size() == 1);
+      SLICER_CHECK(bytecode->operands.size() == 1);
       auto label = bytecode->CastOperand<CodeLocation>(0)->label;
       dex::u4 A = 0;
       if (label->offset != kInvalidOffset) {
@@ -240,15 +240,15 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt21t:  // op vAA, +BBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       auto label = bytecode->CastOperand<CodeLocation>(1)->label;
       dex::u4 B = 0;
       if (label->offset != kInvalidOffset) {
         assert(label->offset <= offset_);
         B = label->offset - offset_;
-        CHECK(B != 0);
-        CHECK((B >> 16) == 0xffff);  // TODO: out of range!
+        SLICER_CHECK(B != 0);
+        SLICER_CHECK((B >> 16) == 0xffff);  // TODO: out of range!
       } else {
         fixups_.push_back(LabelFixup(offset_, label, true));
       }
@@ -258,7 +258,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt22t:  // op vA, vB, +CCCC
     {
-      CHECK(bytecode->operands.size() == 3);
+      SLICER_CHECK(bytecode->operands.size() == 3);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       auto label = bytecode->CastOperand<CodeLocation>(2)->label;
@@ -266,8 +266,8 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
       if (label->offset != kInvalidOffset) {
         assert(label->offset <= offset_);
         C = label->offset - offset_;
-        CHECK(C != 0);
-        CHECK((C >> 16) == 0xffff);  // TODO: out of range!
+        SLICER_CHECK(C != 0);
+        SLICER_CHECK((C >> 16) == 0xffff);  // TODO: out of range!
       } else {
         fixups_.push_back(LabelFixup(offset_, label, true));
       }
@@ -277,14 +277,14 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt31t:  // op vAA, +BBBBBBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       auto label = bytecode->CastOperand<CodeLocation>(1)->label;
       dex::u4 B = 0;
       if (label->offset != kInvalidOffset) {
         assert(label->offset <= offset_);
         B = label->offset - offset_;
-        CHECK(B != 0);
+        SLICER_CHECK(B != 0);
       } else {
         fixups_.push_back(LabelFixup(offset_, label, false));
       }
@@ -295,7 +295,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt23x:  // op vAA, vBB, vCC
     {
-      CHECK(bytecode->operands.size() == 3);
+      SLICER_CHECK(bytecode->operands.size() == 3);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       dex::u4 vC = GetRegC(bytecode, 2);
@@ -305,7 +305,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt22b:  // op vAA, vBB, #+CC
     {
-      CHECK(bytecode->operands.size() == 3);
+      SLICER_CHECK(bytecode->operands.size() == 3);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       dex::u4 C = Trim_S1(bytecode->CastOperand<Const32>(2)->u.u4_value);
@@ -315,7 +315,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt22s:  // op vA, vB, #+CCCC
     {
-      CHECK(bytecode->operands.size() == 3);
+      SLICER_CHECK(bytecode->operands.size() == 3);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       dex::u4 C = Trim_S2(bytecode->CastOperand<Const32>(2)->u.u4_value);
@@ -325,7 +325,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt22c:  // op vA, vB, thing@CCCC
     {
-      CHECK(bytecode->operands.size() == 3);
+      SLICER_CHECK(bytecode->operands.size() == 3);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 vB = GetRegB(bytecode, 1);
       dex::u4 C = bytecode->CastOperand<IndexedOperand>(2)->index;
@@ -335,7 +335,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt21c:  // op vAA, thing@BBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 B = bytecode->CastOperand<IndexedOperand>(1)->index;
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
@@ -344,7 +344,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt31c:  // op vAA, string@BBBBBBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u4 B = bytecode->CastOperand<IndexedOperand>(1)->index;
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
@@ -354,7 +354,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt35c:  // op {vC,vD,vE,vF,vG}, thing@BBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       const auto& regs = bytecode->CastOperand<VRegList>(0)->registers;
       dex::u4 B = bytecode->CastOperand<IndexedOperand>(1)->index;
       dex::u4 A = regs.size();
@@ -375,7 +375,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt3rc:  // op {vCCCC .. v(CCCC+AA-1)}, thing@BBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       auto vreg_range = bytecode->CastOperand<VRegRange>(0);
       dex::u4 A = vreg_range->count;
       dex::u4 B = bytecode->CastOperand<IndexedOperand>(1)->index;
@@ -392,7 +392,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
 
     case dex::kFmt51l:  // op vAA, #+BBBBBBBBBBBBBBBB
     {
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       dex::u4 vA = GetRegA(bytecode, 0);
       dex::u8 B = bytecode->CastOperand<Const64>(1)->u.u8_value;
       bytecode_.Push<dex::u2>(Pack_8_8(vA, opcode));
@@ -403,7 +403,7 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
     } break;
 
     case dex::kFmt21h:  // op vAA, #+BBBB0000[00000000]
-      CHECK(bytecode->operands.size() == 2);
+      SLICER_CHECK(bytecode->operands.size() == 2);
       switch (opcode) {
         case dex::OP_CONST_HIGH16: {
           dex::u4 vA = GetRegA(bytecode, 0);
@@ -420,26 +420,26 @@ bool BytecodeEncoder::Visit(Bytecode* bytecode) {
         } break;
 
         default:
-          FATAL("Unexpected fmt21h opcode: 0x%02x", opcode);
+          SLICER_FATAL("Unexpected fmt21h opcode: 0x%02x", opcode);
       }
       break;
 
     default:
-      FATAL("Unexpected format: 0x%02x", format);
+      SLICER_FATAL("Unexpected format: 0x%02x", format);
   }
 
-  CHECK(bytecode_.size() - buff_offset == 2 * GetWidthFromOpcode(opcode));
+  SLICER_CHECK(bytecode_.size() - buff_offset == 2 * GetWidthFromOpcode(opcode));
   offset_ += GetWidthFromOpcode(opcode);
   return true;
 }
 
 bool BytecodeEncoder::Visit(PackedSwitchPayload* packed_switch) {
-  CHECK(offset_ % 2 == 0);
+  SLICER_CHECK(offset_ % 2 == 0);
 
   // keep track of the switches
   packed_switch->offset = offset_;
   auto& instr = packed_switches_[offset_];
-  CHECK(instr == nullptr);
+  SLICER_CHECK(instr == nullptr);
   instr = packed_switch;
 
   // we're going to fix up the offsets in a later pass
@@ -458,12 +458,12 @@ bool BytecodeEncoder::Visit(PackedSwitchPayload* packed_switch) {
 }
 
 bool BytecodeEncoder::Visit(SparseSwitchPayload* sparse_switch) {
-  CHECK(offset_ % 2 == 0);
+  SLICER_CHECK(offset_ % 2 == 0);
 
   // keep track of the switches
   sparse_switch->offset = offset_;
   auto& instr = sparse_switches_[offset_];
-  CHECK(instr == nullptr);
+  SLICER_CHECK(instr == nullptr);
   instr = sparse_switch;
 
   // we're going to fix up the offsets in a later pass
@@ -482,7 +482,7 @@ bool BytecodeEncoder::Visit(SparseSwitchPayload* sparse_switch) {
 }
 
 bool BytecodeEncoder::Visit(ArrayData* array_data) {
-  CHECK(offset_ % 2 == 0);
+  SLICER_CHECK(offset_ % 2 == 0);
 
   array_data->offset = offset_;
   auto orig_size = bytecode_.size();
@@ -539,20 +539,20 @@ void BytecodeEncoder::FixupSwitchOffsets() {
       FixupSparseSwitch(offset, offset + dex::s4(dex_instr.vB));
     }
     auto isize = dex::GetWidthFromBytecode(ptr);
-    CHECK(isize > 0);
+    SLICER_CHECK(isize > 0);
     ptr += isize;
   }
-  CHECK(ptr == end);
+  SLICER_CHECK(ptr == end);
 }
 
 void BytecodeEncoder::FixupPackedSwitch(dex::u4 base_offset,
                                         dex::u4 payload_offset) {
   auto instr = packed_switches_[payload_offset];
-  CHECK(instr != nullptr);
+  SLICER_CHECK(instr != nullptr);
 
   auto payload = bytecode_.ptr<dex::PackedSwitchPayload>(payload_offset * 2);
-  CHECK(payload->ident == dex::kPackedSwitchSignature);
-  CHECK(reinterpret_cast<dex::u1*>(payload->targets + payload->size) <=
+  SLICER_CHECK(payload->ident == dex::kPackedSwitchSignature);
+  SLICER_CHECK(reinterpret_cast<dex::u1*>(payload->targets + payload->size) <=
         bytecode_.data() + bytecode_.size());
 
   for (int i = 0; i < payload->size; ++i) {
@@ -565,13 +565,13 @@ void BytecodeEncoder::FixupPackedSwitch(dex::u4 base_offset,
 void BytecodeEncoder::FixupSparseSwitch(dex::u4 base_offset,
                                         dex::u4 payload_offset) {
   auto instr = sparse_switches_[payload_offset];
-  CHECK(instr != nullptr);
+  SLICER_CHECK(instr != nullptr);
 
   auto payload = bytecode_.ptr<dex::SparseSwitchPayload>(payload_offset * 2);
-  CHECK(payload->ident == dex::kSparseSwitchSignature);
+  SLICER_CHECK(payload->ident == dex::kSparseSwitchSignature);
 
   dex::s4* const targets = payload->data + payload->size;
-  CHECK(reinterpret_cast<dex::u1*>(targets + payload->size) <=
+  SLICER_CHECK(reinterpret_cast<dex::u1*>(targets + payload->size) <=
         bytecode_.data() + bytecode_.size());
 
   for (int i = 0; i < payload->size; ++i) {
@@ -587,7 +587,7 @@ void BytecodeEncoder::FixupLabels() {
     assert(label_offset != kInvalidOffset);
     assert(label_offset > fixup.offset);
     dex::u4 rel_offset = label_offset - fixup.offset;
-    CHECK(rel_offset != 0);
+    SLICER_CHECK(rel_offset != 0);
     dex::u2* instr = bytecode_.ptr<dex::u2>(fixup.offset * 2);
     if (fixup.short_fixup) {
       // TODO: explicit out-of-range check
@@ -603,9 +603,9 @@ void BytecodeEncoder::FixupLabels() {
 }
 
 void BytecodeEncoder::Encode(ir::Code* ir_code, std::shared_ptr<ir::DexFile> dex_ir) {
-  CHECK(bytecode_.empty());
-  CHECK(offset_ == 0);
-  CHECK(outs_count_ == 0);
+  SLICER_CHECK(bytecode_.empty());
+  SLICER_CHECK(offset_ == 0);
+  SLICER_CHECK(outs_count_ == 0);
 
   packed_switches_.clear();
   sparse_switches_.clear();
diff --git a/slicer/code_ir.cc b/slicer/code_ir.cc
index 7a880c8..3434ca6 100644
--- a/slicer/code_ir.cc
+++ b/slicer/code_ir.cc
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include "code_ir.h"
-#include "common.h"
-#include "dex_bytecode.h"
-#include "dex_format.h"
-#include "dex_ir.h"
-#include "dex_leb128.h"
-#include "bytecode_encoder.h"
-#include "debuginfo_encoder.h"
-#include "tryblocks_encoder.h"
+#include "slicer/common.h"
+#include "slicer/code_ir.h"
+#include "slicer/dex_bytecode.h"
+#include "slicer/dex_format.h"
+#include "slicer/dex_ir.h"
+#include "slicer/dex_leb128.h"
+#include "slicer/bytecode_encoder.h"
+#include "slicer/debuginfo_encoder.h"
+#include "slicer/tryblocks_encoder.h"
 
 #include <assert.h>
 #include <string.h>
@@ -35,7 +35,7 @@ namespace lir {
 
 void CodeIr::Assemble() {
   auto ir_code = ir_method->code;
-  CHECK(ir_code != nullptr);
+  SLICER_CHECK(ir_code != nullptr);
 
   // new .dex bytecode
   //
@@ -78,7 +78,7 @@ void CodeIr::DissasembleTryBlocks(const ir::Code* ir_code) {
       // type
       dex::u4 type_index = dex::ReadULeb128(&ptr);
       handler.ir_type = dex_ir->types_map[type_index];
-      CHECK(handler.ir_type != nullptr);
+      SLICER_CHECK(handler.ir_type != nullptr);
 
       // address
       dex::u4 address = dex::ReadULeb128(&ptr);
@@ -98,7 +98,7 @@ void CodeIr::DissasembleTryBlocks(const ir::Code* ir_code) {
     }
 
     // we should have at least one handler
-    CHECK(!try_block_end->handlers.empty() ||
+    SLICER_CHECK(!try_block_end->handlers.empty() ||
           try_block_end->catch_all != nullptr);
 
     try_begins_.push_back(try_block_begin);
@@ -156,7 +156,7 @@ void CodeIr::DissasembleDebugInfo(const ir::DebugInfo* ir_debug_info) {
       case dex::DBG_ADVANCE_LINE:
         // line_diff
         line += dex::ReadSLeb128(&ptr);
-        WEAK_CHECK(line > 0);
+        SLICER_WEAK_CHECK(line > 0);
         break;
 
       case dex::DBG_START_LOCAL: {
@@ -223,7 +223,7 @@ void CodeIr::DissasembleDebugInfo(const ir::DebugInfo* ir_debug_info) {
         int adjusted_opcode = opcode - dex::DBG_FIRST_SPECIAL;
         line += dex::DBG_LINE_BASE + (adjusted_opcode % dex::DBG_LINE_RANGE);
         address += (adjusted_opcode / dex::DBG_LINE_RANGE);
-        WEAK_CHECK(line > 0);
+        SLICER_WEAK_CHECK(line > 0);
         annotation = Alloc<DbgInfoAnnotation>(dex::DBG_ADVANCE_LINE);
         annotation->operands.push_back(Alloc<LineNumber>(line));
       } break;
@@ -243,7 +243,7 @@ void CodeIr::DissasembleBytecode(const ir::Code* ir_code) {
 
   while (ptr < end) {
     auto isize = dex::GetWidthFromBytecode(ptr);
-    CHECK(isize > 0);
+    SLICER_CHECK(isize > 0);
 
     dex::u4 offset = ptr - begin;
 
@@ -270,7 +270,7 @@ void CodeIr::DissasembleBytecode(const ir::Code* ir_code) {
     instructions.push_back(instr);
     ptr += isize;
   }
-  CHECK(ptr == end);
+  SLICER_CHECK(ptr == end);
 }
 
 void CodeIr::FixupSwitches() {
@@ -294,7 +294,7 @@ template <class I_LIST, class E_LIST>
 static void MergeInstructions(I_LIST& instructions, const E_LIST& extra) {
 
   // the extra instructins must be sorted by offset
-  CHECK(std::is_sorted(extra.begin(), extra.end(),
+  SLICER_CHECK(std::is_sorted(extra.begin(), extra.end(),
                         [](const Instruction* a, const Instruction* b) {
                           return a->offset < b->offset;
                         }));
@@ -360,19 +360,19 @@ PackedSwitchPayload* CodeIr::DecodePackedSwitch(const dex::u2* /*ptr*/,
   // actual decoding is delayed to FixupPackedSwitch()
   // (since the label offsets are relative to the referring
   //  instruction, not the switch data)
-  CHECK(offset % 2 == 0);
+  SLICER_CHECK(offset % 2 == 0);
   auto& instr = packed_switches_[offset].instr;
-  CHECK(instr == nullptr);
+  SLICER_CHECK(instr == nullptr);
   instr = Alloc<PackedSwitchPayload>();
   return instr;
 }
 
 void CodeIr::FixupPackedSwitch(PackedSwitchPayload* instr, dex::u4 base_offset,
                                const dex::u2* ptr) {
-  CHECK(instr->targets.empty());
+  SLICER_CHECK(instr->targets.empty());
 
   auto dex_packed_switch = reinterpret_cast<const dex::PackedSwitchPayload*>(ptr);
-  CHECK(dex_packed_switch->ident == dex::kPackedSwitchSignature);
+  SLICER_CHECK(dex_packed_switch->ident == dex::kPackedSwitchSignature);
 
   instr->first_key = dex_packed_switch->first_key;
   for (dex::u2 i = 0; i < dex_packed_switch->size; ++i) {
@@ -386,19 +386,19 @@ SparseSwitchPayload* CodeIr::DecodeSparseSwitch(const dex::u2* /*ptr*/,
   // actual decoding is delayed to FixupSparseSwitch()
   // (since the label offsets are relative to the referring
   //  instruction, not the switch data)
-  CHECK(offset % 2 == 0);
+  SLICER_CHECK(offset % 2 == 0);
   auto& instr = sparse_switches_[offset].instr;
-  CHECK(instr == nullptr);
+  SLICER_CHECK(instr == nullptr);
   instr = Alloc<SparseSwitchPayload>();
   return instr;
 }
 
 void CodeIr::FixupSparseSwitch(SparseSwitchPayload* instr, dex::u4 base_offset,
                                const dex::u2* ptr) {
-  CHECK(instr->switch_cases.empty());
+  SLICER_CHECK(instr->switch_cases.empty());
 
   auto dex_sparse_switch = reinterpret_cast<const dex::SparseSwitchPayload*>(ptr);
-  CHECK(dex_sparse_switch->ident == dex::kSparseSwitchSignature);
+  SLICER_CHECK(dex_sparse_switch->ident == dex::kSparseSwitchSignature);
 
   auto& data = dex_sparse_switch->data;
   auto& size = dex_sparse_switch->size;
@@ -413,8 +413,8 @@ void CodeIr::FixupSparseSwitch(SparseSwitchPayload* instr, dex::u4 base_offset,
 
 ArrayData* CodeIr::DecodeArrayData(const dex::u2* ptr, dex::u4 offset) {
   auto dex_array_data = reinterpret_cast<const dex::ArrayData*>(ptr);
-  CHECK(dex_array_data->ident == dex::kArrayDataSignature);
-  CHECK(offset % 2 == 0);
+  SLICER_CHECK(dex_array_data->ident == dex::kArrayDataSignature);
+  SLICER_CHECK(offset % 2 == 0);
 
   auto instr = Alloc<ArrayData>();
   instr->data = slicer::MemView(ptr, dex::GetWidthFromBytecode(ptr) * 2);
@@ -497,12 +497,12 @@ Bytecode* CodeIr::DecodeBytecode(const dex::u2* ptr, dex::u4 offset) {
       if (dex_instr.opcode == dex::OP_PACKED_SWITCH) {
         label->aligned = true;
         dex::u4& base_offset = packed_switches_[targetOffset].base_offset;
-        CHECK(base_offset == kInvalidOffset);
+        SLICER_CHECK(base_offset == kInvalidOffset);
         base_offset = offset;
       } else if (dex_instr.opcode == dex::OP_SPARSE_SWITCH) {
         label->aligned = true;
         dex::u4& base_offset = sparse_switches_[targetOffset].base_offset;
-        CHECK(base_offset == kInvalidOffset);
+        SLICER_CHECK(base_offset == kInvalidOffset);
         base_offset = offset;
       } else if (dex_instr.opcode == dex::OP_FILL_ARRAY_DATA) {
         label->aligned = true;
@@ -544,7 +544,7 @@ Bytecode* CodeIr::DecodeBytecode(const dex::u2* ptr, dex::u4 offset) {
 
     case dex::kFmt35c:  // op {vC,vD,vE,vF,vG}, thing@BBBB
     {
-      CHECK(dex_instr.vA <= 5);
+      SLICER_CHECK(dex_instr.vA <= 5);
       auto vreg_list = Alloc<VRegList>();
       for (dex::u4 i = 0; i < dex_instr.vA; ++i) {
         vreg_list->registers.push_back(dex_instr.arg[i]);
@@ -573,7 +573,7 @@ Bytecode* CodeIr::DecodeBytecode(const dex::u2* ptr, dex::u4 offset) {
           break;
 
         default:
-          FATAL("Unexpected opcode 0x%02x", dex_instr.opcode);
+          SLICER_FATAL("Unexpected opcode 0x%02x", dex_instr.opcode);
       }
       break;
 
@@ -583,7 +583,7 @@ Bytecode* CodeIr::DecodeBytecode(const dex::u2* ptr, dex::u4 offset) {
       break;
 
     default:
-      FATAL("Unexpected bytecode format (opcode 0x%02x)", dex_instr.opcode);
+      SLICER_FATAL("Unexpected bytecode format (opcode 0x%02x)", dex_instr.opcode);
   }
 
   return instr;
@@ -593,7 +593,7 @@ Bytecode* CodeIr::DecodeBytecode(const dex::u2* ptr, dex::u4 offset) {
 // (index must be valid != kNoIndex)
 IndexedOperand* CodeIr::GetIndexedOperand(dex::InstructionIndexType index_type,
                                           dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   switch (index_type) {
     case dex::kIndexStringRef:
       return Alloc<String>(dex_ir->strings_map[index], index);
@@ -608,7 +608,7 @@ IndexedOperand* CodeIr::GetIndexedOperand(dex::InstructionIndexType index_type,
       return Alloc<Method>(dex_ir->methods_map[index], index);
 
     default:
-      FATAL("Unexpected index type 0x%02x", index_type);
+      SLICER_FATAL("Unexpected index type 0x%02x", index_type);
   }
 }
 
diff --git a/slicer/common.cc b/slicer/common.cc
index 994d945..c504390 100644
--- a/slicer/common.cc
+++ b/slicer/common.cc
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "common.h"
+#include "slicer/common.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -24,23 +24,23 @@
 
 namespace slicer {
 
-// Helper for the default CHECK() policy
+// Helper for the default SLICER_CHECK() policy
 void _checkFailed(const char* expr, int line, const char* file) {
-  printf("\nCHECK failed [%s] at %s:%d\n\n", expr, file, line);
+  printf("\nSLICER_CHECK failed [%s] at %s:%d\n\n", expr, file, line);
   abort();
 }
 
 // keep track of the failures we already saw to avoid spamming with duplicates
 thread_local std::set<std::pair<int, const char*>> weak_failures;
 
-// Helper for the default WEAK_CHECK() policy
+// Helper for the default SLICER_WEAK_CHECK() policy
 //
 // TODO: implement a modal switch (abort/continue)
 //
 void _weakCheckFailed(const char* expr, int line, const char* file) {
   auto failure_id = std::make_pair(line, file);
   if (weak_failures.find(failure_id) == weak_failures.end()) {
-    printf("\nWEAK_CHECK failed [%s] at %s:%d\n\n", expr, file, line);
+    printf("\nSLICER_WEAK_CHECK failed [%s] at %s:%d\n\n", expr, file, line);
     weak_failures.insert(failure_id);
   }
 }
diff --git a/slicer/control_flow_graph.cc b/slicer/control_flow_graph.cc
index 7da7413..dc7b386 100644
--- a/slicer/control_flow_graph.cc
+++ b/slicer/control_flow_graph.cc
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "control_flow_graph.h"
-#include "chronometer.h"
+#include "slicer/control_flow_graph.h"
+#include "slicer/chronometer.h"
 
 namespace lir {
 
@@ -30,8 +30,8 @@ std::vector<BasicBlock> BasicBlocksVisitor::Finish() {
   //  have labels, annotations, directives, etc. For example it's possible to have
   //  debug annotations (.line, .endlocal, ...) after the last bytecode.
   //
-  WEAK_CHECK(state_ == State::Outside);
-  CHECK(state_ != State::BlockBody);
+  SLICER_WEAK_CHECK(state_ == State::Outside);
+  SLICER_CHECK(state_ != State::BlockBody);
   current_block_.region = {};
   state_ = State::Outside;
   return std::move(basic_blocks_);
diff --git a/slicer/debuginfo_encoder.cc b/slicer/debuginfo_encoder.cc
index cbd9ed8..c99c65d 100644
--- a/slicer/debuginfo_encoder.cc
+++ b/slicer/debuginfo_encoder.cc
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "debuginfo_encoder.h"
-#include "chronometer.h"
-#include "common.h"
+#include "slicer/common.h"
+#include "slicer/debuginfo_encoder.h"
+#include "slicer/chronometer.h"
 
 #include <assert.h>
 
@@ -31,7 +31,7 @@ bool DebugInfoEncoder::Visit(DbgInfoHeader* dbg_header) {
 bool DebugInfoEncoder::Visit(DbgInfoAnnotation* dbg_annotation) {
   // keep the address in sync
   if (last_address_ != dbg_annotation->offset) {
-    CHECK(dbg_annotation->offset > last_address_);
+    SLICER_CHECK(dbg_annotation->offset > last_address_);
     dbginfo_.Push<dex::u1>(dex::DBG_ADVANCE_PC);
     dbginfo_.PushULeb128(dbg_annotation->offset - last_address_);
     last_address_ = dbg_annotation->offset;
@@ -49,10 +49,10 @@ bool DebugInfoEncoder::Visit(DbgInfoAnnotation* dbg_annotation) {
         // it's not perfectly clear from the .dex specification
         // if initial line == 0 is valid, but a number of existing
         // .dex files do this so we have to support it
-        CHECK(line >= 0);
+        SLICER_CHECK(line >= 0);
         line_start_ = line;
       } else {
-        WEAK_CHECK(line > 0);
+        SLICER_WEAK_CHECK(line > 0);
         int delta = line - last_line_;
         int adj_opcode = delta - dex::DBG_LINE_BASE;
         // out of range for special opcode?
@@ -112,7 +112,7 @@ bool DebugInfoEncoder::Visit(DbgInfoAnnotation* dbg_annotation) {
     } break;
 
     default:
-      FATAL("Unexpected debug info opcode: 0x%02x", dbg_annotation->dbg_opcode);
+      SLICER_FATAL("Unexpected debug info opcode: 0x%02x", dbg_annotation->dbg_opcode);
   }
 
   return true;
@@ -121,12 +121,12 @@ bool DebugInfoEncoder::Visit(DbgInfoAnnotation* dbg_annotation) {
 void DebugInfoEncoder::Encode(ir::EncodedMethod* ir_method, std::shared_ptr<ir::DexFile> dex_ir) {
   auto ir_debug_info = ir_method->code->debug_info;
 
-  CHECK(dbginfo_.empty());
-  CHECK(param_names_ == nullptr);
-  CHECK(line_start_ == 0);
-  CHECK(last_line_ == 0);
-  CHECK(last_address_ == 0);
-  CHECK(source_file_ == nullptr);
+  SLICER_CHECK(dbginfo_.empty());
+  SLICER_CHECK(param_names_ == nullptr);
+  SLICER_CHECK(line_start_ == 0);
+  SLICER_CHECK(last_line_ == 0);
+  SLICER_CHECK(last_address_ == 0);
+  SLICER_CHECK(source_file_ == nullptr);
 
   // generate new debug info
   source_file_ = ir_method->decl->parent->class_def->source_file;
@@ -136,7 +136,7 @@ void DebugInfoEncoder::Encode(ir::EncodedMethod* ir_method, std::shared_ptr<ir::
   dbginfo_.Push<dex::u1>(dex::DBG_END_SEQUENCE);
   dbginfo_.Seal(1);
 
-  CHECK(!dbginfo_.empty());
+  SLICER_CHECK(!dbginfo_.empty());
 
   // update ir::DebugInfo
   ir_debug_info->line_start = line_start_;
diff --git a/slicer/dex_bytecode.cc b/slicer/dex_bytecode.cc
index 2449425..7a97f28 100644
--- a/slicer/dex_bytecode.cc
+++ b/slicer/dex_bytecode.cc
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "dex_bytecode.h"
-#include "common.h"
+#include "slicer/dex_bytecode.h"
+#include "slicer/common.h"
 
 #include <assert.h>
 #include <array>
@@ -24,7 +24,7 @@ namespace dex {
 
 Opcode OpcodeFromBytecode(u2 bytecode) {
   Opcode opcode = Opcode(bytecode & 0xff);
-  CHECK(opcode != OP_UNUSED_FF);
+  SLICER_CHECK(opcode != OP_UNUSED_FF);
   return opcode;
 }
 
@@ -194,7 +194,7 @@ static constexpr std::array<OpcodeFlags, kNumPackedOpcodes> gOpcodeFlagsTable =
   /* CONST_CLASS                */ kInstrCanContinue|kInstrCanThrow,
   /* MONITOR_ENTER              */ kInstrCanContinue|kInstrCanThrow,
   /* MONITOR_EXIT               */ kInstrCanContinue|kInstrCanThrow,
-  /* CHECK_CAST                 */ kInstrCanContinue|kInstrCanThrow,
+  /* SLICER_CHECK_CAST                 */ kInstrCanContinue|kInstrCanThrow,
   /* INSTANCE_OF                */ kInstrCanContinue|kInstrCanThrow,
   /* ARRAY_LENGTH               */ kInstrCanContinue|kInstrCanThrow,
   /* NEW_INSTANCE               */ kInstrCanContinue|kInstrCanThrow,
@@ -849,7 +849,7 @@ Instruction DecodeInstruction(const u2* bytecode) {
       switch (dec.vA) {
         case 5:
           // A fifth arg is verboten for inline invokes
-          CHECK(format != kFmt35mi);
+          SLICER_CHECK(format != kFmt35mi);
 
           // Per note at the top of this format decoder, the
           // fifth argument comes from the A field in the
@@ -872,7 +872,7 @@ Instruction DecodeInstruction(const u2* bytecode) {
           // Valid, but no need to do anything
           break;
         default:
-          CHECK(!"Invalid arg count in 35c/35ms/35mi");
+          SLICER_CHECK(!"Invalid arg count in 35c/35ms/35mi");
           break;
       }
     } break;
@@ -888,7 +888,7 @@ Instruction DecodeInstruction(const u2* bytecode) {
       dec.vB_wide = FetchU8(bytecode + 1);
       break;
     default:
-      FATAL("Can't decode unexpected format 0x%02x", format);
+      SLICER_FATAL("Can't decode unexpected format 0x%02x", format);
   }
 
   return dec;
diff --git a/slicer/dex_format.cc b/slicer/dex_format.cc
index f2abb3c..7dbc762 100644
--- a/slicer/dex_format.cc
+++ b/slicer/dex_format.cc
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "dex_format.h"
-#include "common.h"
+#include "slicer/dex_format.h"
+#include "slicer/common.h"
 
 #include <zlib.h>
 #include <sstream>
@@ -46,7 +46,7 @@ static const char* PrimitiveTypeName(char type_char) {
     case 'V': return "void";
     case 'Z': return "boolean";
   }
-  CHECK(!"unexpected type");
+  SLICER_CHECK(!"unexpected type");
   return nullptr;
 }
 
@@ -64,14 +64,14 @@ std::string DescriptorToDecl(const char* descriptor) {
 
   if (*descriptor == 'L') {
     for (++descriptor; *descriptor != ';'; ++descriptor) {
-      CHECK(*descriptor != '\0');
+      SLICER_CHECK(*descriptor != '\0');
       ss << (*descriptor == '/' ? '.' : *descriptor);
     }
   } else {
     ss << PrimitiveTypeName(*descriptor);
   }
 
-  CHECK(descriptor[1] == '\0');
+  SLICER_CHECK(descriptor[1] == '\0');
 
   // add the array brackets
   for (int i = 0; i < array_dimensions; ++i) {
@@ -95,11 +95,11 @@ char DescriptorToShorty(const char* descriptor) {
   if (short_descriptor == 'L') {
     // skip the full class name
     for(; *descriptor && *descriptor != ';'; ++descriptor);
-    CHECK(*descriptor == ';');
+    SLICER_CHECK(*descriptor == ';');
   }
 
-  CHECK(descriptor[1] == '\0');
-  CHECK(short_descriptor == 'L' || PrimitiveTypeName(short_descriptor) != nullptr);
+  SLICER_CHECK(descriptor[1] == '\0');
+  SLICER_CHECK(short_descriptor == 'L' || PrimitiveTypeName(short_descriptor) != nullptr);
 
   return array_dimensions > 0 ? 'L' : short_descriptor;
 }
diff --git a/slicer/dex_ir.cc b/slicer/dex_ir.cc
index 9c16139..0ab1726 100644
--- a/slicer/dex_ir.cc
+++ b/slicer/dex_ir.cc
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include "dex_ir.h"
-#include "chronometer.h"
-#include "dex_utf8.h"
-#include "dex_format.h"
+#include "slicer/dex_ir.h"
+#include "slicer/chronometer.h"
+#include "slicer/dex_utf8.h"
+#include "slicer/dex_format.h"
 
 #include <algorithm>
 #include <cstdint>
@@ -140,7 +140,7 @@ void DexFile::TopSortClassIndex(Class* irClass, dex::u4* nextIndex) {
       }
     }
 
-    CHECK(*nextIndex < classes.size());
+    SLICER_CHECK(*nextIndex < classes.size());
     irClass->index = (*nextIndex)++;
   }
 }
@@ -162,7 +162,7 @@ void DexFile::SortClassIndexes() {
 static void SortEncodedFields(std::vector<EncodedField*>* fields) {
   std::sort(fields->begin(), fields->end(),
             [](const EncodedField* a, const EncodedField* b) {
-              CHECK(a->decl->index != b->decl->index || a == b);
+              SLICER_CHECK(a->decl->index != b->decl->index || a == b);
               return a->decl->index < b->decl->index;
             });
 }
@@ -171,7 +171,7 @@ static void SortEncodedFields(std::vector<EncodedField*>* fields) {
 static void SortEncodedMethods(std::vector<EncodedMethod*>* methods) {
   std::sort(methods->begin(), methods->end(),
             [](const EncodedMethod* a, const EncodedMethod* b) {
-              CHECK(a->decl->index != b->decl->index || a == b);
+              SLICER_CHECK(a->decl->index != b->decl->index || a == b);
               return a->decl->index < b->decl->index;
             });
 }
@@ -256,9 +256,9 @@ void DexFile::Normalize() {
   SortClassIndexes();
 
   IndexItems(classes, [&](const own<Class>& a, const own<Class>& b) {
-    CHECK(a->index < classes.size());
-    CHECK(b->index < classes.size());
-    CHECK(a->index != b->index || a == b);
+    SLICER_CHECK(a->index < classes.size());
+    SLICER_CHECK(b->index < classes.size());
+    SLICER_CHECK(a->index != b->index || a == b);
     return a->index < b->index;
   });
 
diff --git a/slicer/dex_ir_builder.cc b/slicer/dex_ir_builder.cc
index b6ee716..a078a62 100644
--- a/slicer/dex_ir_builder.cc
+++ b/slicer/dex_ir_builder.cc
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "dex_ir_builder.h"
+#include "slicer/dex_ir_builder.h"
 
 #include <sstream>
 #include <string.h>
@@ -78,7 +78,7 @@ String* Builder::GetAsciiString(const char* cstr) {
   // update the index -> ir node map
   auto new_index = dex_ir_->strings_indexes.AllocateIndex();
   auto& ir_node = dex_ir_->strings_map[new_index];
-  CHECK(ir_node == nullptr);
+  SLICER_CHECK(ir_node == nullptr);
   ir_node = ir_string;
   ir_string->orig_index = new_index;
 
@@ -106,7 +106,7 @@ Type* Builder::GetType(String* descriptor) {
   // update the index -> ir node map
   auto new_index = dex_ir_->types_indexes.AllocateIndex();
   auto& ir_node = dex_ir_->types_map[new_index];
-  CHECK(ir_node == nullptr);
+  SLICER_CHECK(ir_node == nullptr);
   ir_node = ir_type;
   ir_type->orig_index = new_index;
 
@@ -165,7 +165,7 @@ Proto* Builder::GetProto(Type* return_type, TypeList* param_types) {
   // update the index -> ir node map
   auto new_index = dex_ir_->protos_indexes.AllocateIndex();
   auto& ir_node = dex_ir_->protos_map[new_index];
-  CHECK(ir_node == nullptr);
+  SLICER_CHECK(ir_node == nullptr);
   ir_node = ir_proto;
   ir_proto->orig_index = new_index;
 
@@ -194,7 +194,7 @@ FieldDecl* Builder::GetFieldDecl(String* name, Type* type, Type* parent) {
   // update the index -> ir node map
   auto new_index = dex_ir_->fields_indexes.AllocateIndex();
   auto& ir_node = dex_ir_->fields_map[new_index];
-  CHECK(ir_node == nullptr);
+  SLICER_CHECK(ir_node == nullptr);
   ir_node = ir_field;
   ir_field->orig_index = new_index;
 
@@ -220,7 +220,7 @@ MethodDecl* Builder::GetMethodDecl(String* name, Proto* proto, Type* parent) {
   // update the index -> ir node map
   auto new_index = dex_ir_->methods_indexes.AllocateIndex();
   auto& ir_node = dex_ir_->methods_map[new_index];
-  CHECK(ir_node == nullptr);
+  SLICER_CHECK(ir_node == nullptr);
   ir_node = ir_method;
   ir_method->orig_index = new_index;
 
diff --git a/slicer/dex_utf8.cc b/slicer/dex_utf8.cc
index a30adaf..c174626 100644
--- a/slicer/dex_utf8.cc
+++ b/slicer/dex_utf8.cc
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "dex_format.h"
+#include "slicer/dex_format.h"
 
 namespace dex {
 
diff --git a/slicer/arrayview.h b/slicer/export/slicer/arrayview.h
index 527a3bb..53c624c 100644
--- a/slicer/arrayview.h
+++ b/slicer/export/slicer/arrayview.h
@@ -39,7 +39,7 @@ class ArrayView {
   T* data() const { return begin_; }
 
   T& operator[](size_t i) const {
-    CHECK(i < size());
+    SLICER_CHECK(i < size());
     return *(begin_ + i);
   }
 
diff --git a/slicer/buffer.h b/slicer/export/slicer/buffer.h
index f98f617..d20324d 100644
--- a/slicer/buffer.h
+++ b/slicer/export/slicer/buffer.h
@@ -60,7 +60,7 @@ class Buffer {
  public:
   // Align the total size and prevent further changes
   size_t Seal(size_t alignment) {
-    CHECK(!sealed_);
+    SLICER_CHECK(!sealed_);
     Align(alignment);
     sealed_ = true;
     return size();
@@ -73,7 +73,7 @@ class Buffer {
   //
   template <class T>
   T* ptr(size_t offset) {
-    CHECK(offset + sizeof(T) <= size_);
+    SLICER_CHECK(offset + sizeof(T) <= size_);
     return reinterpret_cast<T*>(buff_ + offset);
   }
 
@@ -115,7 +115,7 @@ class Buffer {
   }
 
   size_t Push(const Buffer& buff) {
-    CHECK(&buff != this);
+    SLICER_CHECK(&buff != this);
     return Push(buff.data(), buff.size());
   }
 
@@ -153,17 +153,17 @@ class Buffer {
   }
 
   const dex::u1* data() const {
-    CHECK(buff_ != nullptr);
+    SLICER_CHECK(buff_ != nullptr);
     return buff_;
   }
 
  private:
   void Expand(size_t size) {
-    CHECK(!sealed_);
+    SLICER_CHECK(!sealed_);
     if (size_ + size > capacity_) {
       capacity_ = std::max(size_t(capacity_ * 1.5), size_ + size);
       buff_ = static_cast<dex::u1*>(::realloc(buff_, capacity_));
-      CHECK(buff_ != nullptr);
+      SLICER_CHECK(buff_ != nullptr);
     }
     size_ += size;
   }
diff --git a/slicer/bytecode_encoder.h b/slicer/export/slicer/bytecode_encoder.h
index 28d2bfa..28d2bfa 100644
--- a/slicer/bytecode_encoder.h
+++ b/slicer/export/slicer/bytecode_encoder.h
diff --git a/slicer/chronometer.h b/slicer/export/slicer/chronometer.h
index a293ac4..a293ac4 100644
--- a/slicer/chronometer.h
+++ b/slicer/export/slicer/chronometer.h
diff --git a/slicer/code_ir.h b/slicer/export/slicer/code_ir.h
index 916d282..2d028b9 100644
--- a/slicer/code_ir.h
+++ b/slicer/export/slicer/code_ir.h
@@ -242,7 +242,7 @@ struct Bytecode : public Instruction {
   template<class T>
   T* CastOperand(int index) const {
     T* operand = dynamic_cast<T*>(operands[index]);
-    CHECK(operand != nullptr);
+    SLICER_CHECK(operand != nullptr);
     return operand;
   }
 
@@ -312,7 +312,7 @@ struct LineNumber : public Operand {
   int line = 0;
 
   LineNumber(int line) : line(line) {
-    WEAK_CHECK(line > 0);
+    SLICER_WEAK_CHECK(line > 0);
   }
 
   virtual bool Accept(Visitor* visitor) override { return visitor->Visit(this); }
@@ -327,7 +327,7 @@ struct DbgInfoAnnotation : public Instruction {
   template<class T>
   T* CastOperand(int index) const {
     T* operand = dynamic_cast<T*>(operands[index]);
-    CHECK(operand != nullptr);
+    SLICER_CHECK(operand != nullptr);
     return operand;
   }
 
diff --git a/slicer/common.h b/slicer/export/slicer/common.h
index 693ccb3..4c2554c 100644
--- a/slicer/common.h
+++ b/slicer/export/slicer/common.h
@@ -21,27 +21,27 @@ namespace slicer {
 // Encapsulate the runtime check and error reporting policy.
 // (currently a simple fail-fast but the the intention is to allow customization)
 void _checkFailed(const char* expr, int line, const char* file) __attribute__((noreturn));
-#define CHECK(expr) do { if(!(expr)) slicer::_checkFailed(#expr, __LINE__, __FILE__); } while(false)
+#define SLICER_CHECK(expr) do { if(!(expr)) slicer::_checkFailed(#expr, __LINE__, __FILE__); } while(false)
 
-// A modal check: if the strict mode is enabled, it behaves as a CHECK,
+// A modal check: if the strict mode is enabled, it behaves as a SLICER_CHECK,
 // otherwise it will only log a warning and continue
 //
-// NOTE: we use WEAK_CHECK for .dex format validations that are frequently
+// NOTE: we use SLICER_WEAK_CHECK for .dex format validations that are frequently
 //   violated by existing apps. So we need to be able to annotate these common
 //   problems and potentially ignoring them for parity with the Android runtime.
 //
 void _weakCheckFailed(const char* expr, int line, const char* file);
-#define WEAK_CHECK(expr) do { if(!(expr)) slicer::_weakCheckFailed(#expr, __LINE__, __FILE__); } while(false)
+#define SLICER_WEAK_CHECK(expr) do { if(!(expr)) slicer::_weakCheckFailed(#expr, __LINE__, __FILE__); } while(false)
 
 // Report a fatal condition with a printf-formatted message
 void _fatal(const char* format, ...) __attribute__((noreturn));
-#define FATAL(format, ...) slicer::_fatal("\nFATAL: " format "\n\n", ##__VA_ARGS__);
+#define SLICER_FATAL(format, ...) slicer::_fatal("\nSLICER_FATAL: " format "\n\n", ##__VA_ARGS__);
 
 // Annotation customization point for extra validation / state.
 #ifdef NDEBUG
-#define EXTRA(x)
+#define SLICER_EXTRA(x)
 #else
-#define EXTRA(x) x
+#define SLICER_EXTRA(x) x
 #endif
 
 } // namespace slicer
diff --git a/slicer/control_flow_graph.h b/slicer/export/slicer/control_flow_graph.h
index 05934ff..05934ff 100644
--- a/slicer/control_flow_graph.h
+++ b/slicer/export/slicer/control_flow_graph.h
diff --git a/slicer/debuginfo_encoder.h b/slicer/export/slicer/debuginfo_encoder.h
index a46d4d6..a46d4d6 100644
--- a/slicer/debuginfo_encoder.h
+++ b/slicer/export/slicer/debuginfo_encoder.h
diff --git a/slicer/dex_bytecode.h b/slicer/export/slicer/dex_bytecode.h
index defcfcd..defcfcd 100644
--- a/slicer/dex_bytecode.h
+++ b/slicer/export/slicer/dex_bytecode.h
diff --git a/slicer/dex_format.h b/slicer/export/slicer/dex_format.h
index 77a247d..77a247d 100644
--- a/slicer/dex_format.h
+++ b/slicer/export/slicer/dex_format.h
diff --git a/slicer/dex_ir.h b/slicer/export/slicer/dex_ir.h
index 67e5d11..1d5dc3c 100644
--- a/slicer/dex_ir.h
+++ b/slicer/export/slicer/dex_ir.h
@@ -40,11 +40,11 @@
 // it's expected to construct the IR for the single modified class only
 // (and include only the nodes referenced from that class)
 
-#define IR_TYPE     \
+#define SLICER_IR_TYPE     \
   using Node::Node; \
   friend struct DexFile;
 
-#define IR_INDEXED_TYPE           \
+#define SLICER_IR_INDEXED_TYPE           \
   using IndexedNode::IndexedNode; \
   friend struct DexFile;
 
@@ -114,7 +114,7 @@ struct Node {
 // TODO: consider moving the indexing to the writer.
 //
 struct IndexedNode : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   // this is the index in the generated image
   // (not the original index)
@@ -126,7 +126,7 @@ struct IndexedNode : public Node {
 };
 
 struct EncodedValue : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   dex::u1 type;
   union {
@@ -147,17 +147,17 @@ struct EncodedValue : public Node {
     bool bool_value;
   } u;
 
-  EXTRA(slicer::MemView original);
+  SLICER_EXTRA(slicer::MemView original);
 };
 
 struct EncodedArray : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   std::vector<EncodedValue*> values;
 };
 
 struct String : public IndexedNode {
-  IR_INDEXED_TYPE;
+  SLICER_IR_INDEXED_TYPE;
 
   // opaque DEX "string_data_item"
   slicer::MemView data;
@@ -170,7 +170,7 @@ struct String : public IndexedNode {
 };
 
 struct Type : public IndexedNode {
-  IR_INDEXED_TYPE;
+  SLICER_IR_INDEXED_TYPE;
 
   enum class Category { Void, Scalar, WideScalar, Reference };
 
@@ -182,13 +182,13 @@ struct Type : public IndexedNode {
 };
 
 struct TypeList : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   std::vector<Type*> types;
 };
 
 struct Proto : public IndexedNode {
-  IR_INDEXED_TYPE;
+  SLICER_IR_INDEXED_TYPE;
 
   String* shorty;
   Type* return_type;
@@ -198,7 +198,7 @@ struct Proto : public IndexedNode {
 };
 
 struct FieldDecl : public IndexedNode {
-  IR_INDEXED_TYPE;
+  SLICER_IR_INDEXED_TYPE;
 
   String* name;
   Type* type;
@@ -206,14 +206,14 @@ struct FieldDecl : public IndexedNode {
 };
 
 struct EncodedField : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   FieldDecl* decl;
   dex::u4 access_flags;
 };
 
 struct DebugInfo : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   dex::u4 line_start;
   std::vector<String*> param_names;
@@ -224,7 +224,7 @@ struct DebugInfo : public Node {
 };
 
 struct Code : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   dex::u2 registers;
   dex::u2 ins_count;
@@ -236,7 +236,7 @@ struct Code : public Node {
 };
 
 struct MethodDecl : public IndexedNode {
-  IR_INDEXED_TYPE;
+  SLICER_IR_INDEXED_TYPE;
 
   String* name;
   Proto* prototype;
@@ -244,7 +244,7 @@ struct MethodDecl : public IndexedNode {
 };
 
 struct EncodedMethod : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   MethodDecl* decl;
   Code* code;
@@ -252,14 +252,14 @@ struct EncodedMethod : public Node {
 };
 
 struct AnnotationElement : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   String* name;
   EncodedValue* value;
 };
 
 struct Annotation : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   Type* type;
   std::vector<AnnotationElement*> elements;
@@ -267,40 +267,40 @@ struct Annotation : public Node {
 };
 
 struct AnnotationSet : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   std::vector<Annotation*> annotations;
 };
 
 struct AnnotationSetRefList : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   std::vector<AnnotationSet*> annotations;
 };
 
 struct FieldAnnotation : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   FieldDecl* field_decl;
   AnnotationSet* annotations;
 };
 
 struct MethodAnnotation : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   MethodDecl* method_decl;
   AnnotationSet* annotations;
 };
 
 struct ParamAnnotation : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   MethodDecl* method_decl;
   AnnotationSetRefList* annotations;
 };
 
 struct AnnotationsDirectory : public Node {
-  IR_TYPE;
+  SLICER_IR_TYPE;
 
   AnnotationSet* class_annotation;
   std::vector<FieldAnnotation*> field_annotations;
@@ -309,7 +309,7 @@ struct AnnotationsDirectory : public Node {
 };
 
 struct Class : public IndexedNode {
-  IR_INDEXED_TYPE;
+  SLICER_IR_INDEXED_TYPE;
 
   Type* type;
   dex::u4 access_flags;
@@ -471,5 +471,5 @@ private:
 
 }  // namespace ir
 
-#undef IR_TYPE
-#undef IR_INDEXED_TYPE
+#undef SLICER_IR_TYPE
+#undef SLICER_IR_INDEXED_TYPE
diff --git a/slicer/dex_ir_builder.h b/slicer/export/slicer/dex_ir_builder.h
index c099d3a..c099d3a 100644
--- a/slicer/dex_ir_builder.h
+++ b/slicer/export/slicer/dex_ir_builder.h
diff --git a/slicer/dex_leb128.h b/slicer/export/slicer/dex_leb128.h
index a869eff..a869eff 100644
--- a/slicer/dex_leb128.h
+++ b/slicer/export/slicer/dex_leb128.h
diff --git a/slicer/dex_utf8.h b/slicer/export/slicer/dex_utf8.h
index 78641b6..78641b6 100644
--- a/slicer/dex_utf8.h
+++ b/slicer/export/slicer/dex_utf8.h
diff --git a/slicer/hash_table.h b/slicer/export/slicer/hash_table.h
index c68eaca..7eca41a 100644
--- a/slicer/hash_table.h
+++ b/slicer/export/slicer/hash_table.h
@@ -124,7 +124,7 @@ HashTable<Key, T, Hash>::Partition::Partition(Index size, const Hash& hasher)
 //
 template<class Key, class T, class Hash>
 bool HashTable<Key, T, Hash>::Partition::Insert(T* value) {
-  CHECK(value != nullptr);
+  SLICER_CHECK(value != nullptr);
   // overflow?
   if (buckets_.size() + 1 > buckets_.capacity()) {
     return false;
@@ -163,7 +163,7 @@ template<class Key, class T, class Hash>
 void HashTable<Key, T, Hash>::Partition::InsertAll(const Partition& src) {
   for (const auto& bucket : src.buckets_) {
     if (bucket.value != nullptr) {
-      CHECK(Insert(bucket.value));
+      SLICER_CHECK(Insert(bucket.value));
     }
   }
 }
@@ -180,7 +180,7 @@ void HashTable<Key, T, Hash>::Insert(T* value) {
     if (full_table_) {
       new_hash_table->InsertAll(*full_table_);
     }
-    CHECK(new_hash_table->Insert(value));
+    SLICER_CHECK(new_hash_table->Insert(value));
     full_table_ = std::move(insertion_table_);
     insertion_table_ = std::move(new_hash_table);
   }
@@ -211,7 +211,7 @@ void HashTable<Key, T, Hash>::Partition::PrintStats(const char* name, bool verbo
       ++used_buckets;
       int chain_length = 0;
       for (Index ci = i; buckets_[ci].next != kInvalidIndex; ci = buckets_[ci].next) {
-        CHECK(buckets_[ci].value != nullptr);
+        SLICER_CHECK(buckets_[ci].value != nullptr);
         ++chain_length;
         if (verbose) printf("*");
       }
diff --git a/slicer/index_map.h b/slicer/export/slicer/index_map.h
index 46600d0..b7fa1c3 100644
--- a/slicer/index_map.h
+++ b/slicer/export/slicer/index_map.h
@@ -39,7 +39,7 @@ class IndexMap {
     if (index >= indexes_map_.size()) {
       indexes_map_.resize(index + 1);
     }
-    CHECK(!indexes_map_[index]);
+    SLICER_CHECK(!indexes_map_[index]);
     indexes_map_[index] = true;
   }
 
diff --git a/slicer/instrumentation.h b/slicer/export/slicer/instrumentation.h
index eae4517..f5210fd 100644
--- a/slicer/instrumentation.h
+++ b/slicer/export/slicer/instrumentation.h
@@ -46,7 +46,7 @@ class EntryHook : public Transformation {
       : hook_method_id_(hook_method_id),
         use_object_type_for_this_argument_(use_object_type_for_this_argument) {
     // hook method signature is generated automatically
-    CHECK(hook_method_id_.signature == nullptr);
+    SLICER_CHECK(hook_method_id_.signature == nullptr);
   }
 
   virtual bool Apply(lir::CodeIr* code_ir) override;
@@ -66,7 +66,7 @@ class ExitHook : public Transformation {
  public:
   explicit ExitHook(const ir::MethodId& hook_method_id) : hook_method_id_(hook_method_id) {
     // hook method signature is generated automatically
-    CHECK(hook_method_id_.signature == nullptr);
+    SLICER_CHECK(hook_method_id_.signature == nullptr);
   }
 
   virtual bool Apply(lir::CodeIr* code_ir) override;
@@ -85,7 +85,7 @@ class DetourVirtualInvoke : public Transformation {
     : orig_method_id_(orig_method_id), detour_method_id_(detour_method_id) {
     // detour method signature is automatically created
     // to match the original method and must not be explicitly specified
-    CHECK(detour_method_id_.signature == nullptr);
+    SLICER_CHECK(detour_method_id_.signature == nullptr);
   }
 
   virtual bool Apply(lir::CodeIr* code_ir) override;
@@ -100,13 +100,13 @@ class AllocateScratchRegs : public Transformation {
  public:
   explicit AllocateScratchRegs(int allocate_count, bool allow_renumbering = true)
     : allocate_count_(allocate_count), allow_renumbering_(allow_renumbering) {
-    CHECK(allocate_count > 0);
+    SLICER_CHECK(allocate_count > 0);
   }
 
   virtual bool Apply(lir::CodeIr* code_ir) override;
 
   const std::set<dex::u4>& ScratchRegs() const {
-    CHECK(scratch_regs_.size() == static_cast<size_t>(allocate_count_));
+    SLICER_CHECK(scratch_regs_.size() == static_cast<size_t>(allocate_count_));
     return scratch_regs_;
   }
 
@@ -134,7 +134,7 @@ class AllocateScratchRegs : public Transformation {
 //    slicer::MethodInstrumenter mi(dex_ir);
 //    mi.AddTransformation<slicer::EntryHook>(ir::MethodId("LTracer;", "OnEntry"));
 //    mi.AddTransformation<slicer::ExitHook>(ir::MethodId("LTracer;", "OnExit"));
-//    CHECK(mi.InstrumentMethod(ir::MethodId("LHello;", "Test", "(I)I")));
+//    SLICER_CHECK(mi.InstrumentMethod(ir::MethodId("LHello;", "Test", "(I)I")));
 //    ...
 //
 class MethodInstrumenter {
diff --git a/slicer/intrusive_list.h b/slicer/export/slicer/intrusive_list.h
index 855f422..67408ae 100644
--- a/slicer/intrusive_list.h
+++ b/slicer/export/slicer/intrusive_list.h
@@ -114,7 +114,7 @@ class IntrusiveList {
   }
 
   void Remove(T* pos) {
-    CHECK(pos != end_);
+    SLICER_CHECK(pos != end_);
     if (pos->prev != nullptr) {
       assert(pos != begin_);
       pos->prev->next = pos->next;
diff --git a/slicer/memview.h b/slicer/export/slicer/memview.h
index 99fc978..99fc978 100644
--- a/slicer/memview.h
+++ b/slicer/export/slicer/memview.h
diff --git a/slicer/reader.h b/slicer/export/slicer/reader.h
index 668eb2b..4e08f52 100644
--- a/slicer/reader.h
+++ b/slicer/export/slicer/reader.h
@@ -104,7 +104,7 @@ class Reader {
   // Convert a file pointer (absolute offset) to an in-memory pointer
   template <class T>
   const T* ptr(int offset) const {
-    CHECK(offset >= 0 && offset + sizeof(T) <= size_);
+    SLICER_CHECK(offset >= 0 && offset + sizeof(T) <= size_);
     return reinterpret_cast<const T*>(image_ + offset);
   }
 
@@ -112,7 +112,7 @@ class Reader {
   // (offset should be inside the data section)
   template <class T>
   const T* dataPtr(int offset) const {
-    CHECK(offset >= header_->data_off && offset + sizeof(T) <= size_);
+    SLICER_CHECK(offset >= header_->data_off && offset + sizeof(T) <= size_);
     return reinterpret_cast<const T*>(image_ + offset);
   }
 
diff --git a/slicer/scopeguard.h b/slicer/export/slicer/scopeguard.h
index fe20b9b..28e3bc9 100644
--- a/slicer/scopeguard.h
+++ b/slicer/export/slicer/scopeguard.h
@@ -24,7 +24,7 @@ namespace slicer {
 // Here is how it's used:
 //
 //  FILE* file = std::fopen(...);
-//  SCOPE_EXIT {
+//  SLICER_SCOPE_EXIT {
 //      std::fclose(file);
 //  };
 //
@@ -65,12 +65,12 @@ public:
     }
 };
 
-#define SG_MACRO_CONCAT2(a, b) a ## b
-#define SG_MACRO_CONCAT(a, b) SG_MACRO_CONCAT2(a, b)
-#define SG_ANONYMOUS(prefix)  SG_MACRO_CONCAT(prefix, __COUNTER__)
+#define SLICER_SG_MACRO_CONCAT2(a, b) a ## b
+#define SLICER_SG_MACRO_CONCAT(a, b) SLICER_SG_MACRO_CONCAT2(a, b)
+#define SLICER_SG_ANONYMOUS(prefix)  SLICER_SG_MACRO_CONCAT(prefix, __COUNTER__)
 
-#define SCOPE_EXIT \
-    auto SG_ANONYMOUS(_scope_guard_) = slicer::ScopeGuardHelper() << [&]()
+#define SLICER_SCOPE_EXIT \
+    auto SLICER_SG_ANONYMOUS(_scope_guard_) = slicer::ScopeGuardHelper() << [&]()
 
 } // namespace slicer
 
diff --git a/slicer/tryblocks_encoder.h b/slicer/export/slicer/tryblocks_encoder.h
index 32e0143..32e0143 100644
--- a/slicer/tryblocks_encoder.h
+++ b/slicer/export/slicer/tryblocks_encoder.h
diff --git a/slicer/writer.h b/slicer/export/slicer/writer.h
index 4a3f08f..00a04ce 100644
--- a/slicer/writer.h
+++ b/slicer/export/slicer/writer.h
@@ -39,18 +39,18 @@ class Section : public slicer::Buffer {
   Section& operator=(const Section&) = delete;
 
   void SetOffset(dex::u4 offset) {
-    CHECK(offset > 0 && offset % 4 == 0);
+    SLICER_CHECK(offset > 0 && offset % 4 == 0);
     offset_ = offset;
   }
 
   dex::u4 SectionOffset() const {
-    CHECK(offset_ > 0 && offset_ % 4 == 0);
+    SLICER_CHECK(offset_ > 0 && offset_ % 4 == 0);
     return ItemsCount() > 0 ? offset_ : 0;
   }
 
   dex::u4 AbsoluteOffset(dex::u4 itemOffset) const {
-    CHECK(offset_ > 0);
-    CHECK(itemOffset < size());
+    SLICER_CHECK(offset_ > 0);
+    SLICER_CHECK(itemOffset < size());
     return offset_ + itemOffset;
   }
 
@@ -96,7 +96,7 @@ class Index {
   }
 
   dex::u4 SectionOffset() const {
-    CHECK(offset_ > 0 && offset_ % 4 == 0);
+    SLICER_CHECK(offset_ > 0 && offset_ % 4 == 0);
     return ItemsCount() > 0 ? offset_ : 0;
   }
 
@@ -110,7 +110,7 @@ class Index {
   dex::u4 size() const { return count_ * sizeof(T); }
 
   T& operator[](int i) {
-    CHECK(i >= 0 && i < count_);
+    SLICER_CHECK(i >= 0 && i < count_);
     return values_[i];
   }
 
diff --git a/slicer/instrumentation.cc b/slicer/instrumentation.cc
index 89dcb3a..55e2ae8 100644
--- a/slicer/instrumentation.cc
+++ b/slicer/instrumentation.cc
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#include "instrumentation.h"
-#include "dex_ir_builder.h"
+#include "slicer/instrumentation.h"
+#include "slicer/dex_ir_builder.h"
 
 namespace slicer {
 
@@ -107,22 +107,22 @@ bool ExitHook::Apply(lir::CodeIr* code_ir) {
 
     switch (bytecode->opcode) {
       case dex::OP_RETURN_VOID:
-        CHECK(return_void);
+        SLICER_CHECK(return_void);
         break;
       case dex::OP_RETURN:
-        CHECK(!return_void);
+        SLICER_CHECK(!return_void);
         move_result_opcode = dex::OP_MOVE_RESULT;
         reg = bytecode->CastOperand<lir::VReg>(0)->reg;
         reg_count = 1;
         break;
       case dex::OP_RETURN_OBJECT:
-        CHECK(!return_void);
+        SLICER_CHECK(!return_void);
         move_result_opcode = dex::OP_MOVE_RESULT_OBJECT;
         reg = bytecode->CastOperand<lir::VReg>(0)->reg;
         reg_count = 1;
         break;
       case dex::OP_RETURN_WIDE:
-        CHECK(!return_void);
+        SLICER_CHECK(!return_void);
         move_result_opcode = dex::OP_MOVE_RESULT_WIDE;
         reg = bytecode->CastOperand<lir::VRegPair>(0)->base_reg;
         reg_count = 2;
@@ -222,7 +222,7 @@ bool DetourVirtualInvoke::Apply(lir::CodeIr* code_ir) {
 class RegsRenumberVisitor : public lir::Visitor {
  public:
   RegsRenumberVisitor(int shift) : shift_(shift) {
-    CHECK(shift > 0);
+    SLICER_CHECK(shift > 0);
   }
 
  private:
@@ -272,7 +272,7 @@ class RegsRenumberVisitor : public lir::Visitor {
 //  make existing bytecodes "unencodable" (if they have 4 bit reg fields)
 //
 void AllocateScratchRegs::RegsRenumbering(lir::CodeIr* code_ir) {
-  CHECK(left_to_allocate_ > 0);
+  SLICER_CHECK(left_to_allocate_ > 0);
   int delta = std::min(left_to_allocate_,
                        16 - static_cast<int>(code_ir->ir_method->code->registers));
   if (delta < 1) {
@@ -301,8 +301,8 @@ void AllocateScratchRegs::RegsRenumbering(lir::CodeIr* code_ir) {
 //
 void AllocateScratchRegs::ShiftParams(lir::CodeIr* code_ir) {
   const auto ir_method = code_ir->ir_method;
-  CHECK(ir_method->code->ins_count > 0);
-  CHECK(left_to_allocate_ > 0);
+  SLICER_CHECK(ir_method->code->ins_count > 0);
+  SLICER_CHECK(left_to_allocate_ > 0);
 
   // build a param list with the explicit "this" argument for non-static methods
   std::vector<ir::Type*> param_types;
@@ -321,7 +321,7 @@ void AllocateScratchRegs::ShiftParams(lir::CodeIr* code_ir) {
 
   const dex::u4 regs = ir_method->code->registers;
   const dex::u4 ins_count = ir_method->code->ins_count;
-  CHECK(regs >= ins_count);
+  SLICER_CHECK(regs >= ins_count);
 
   // generate the args "relocation" instructions
   auto first_instr = code_ir->instructions.begin();
@@ -348,7 +348,7 @@ void AllocateScratchRegs::ShiftParams(lir::CodeIr* code_ir) {
         reg += 2;
         break;
       case ir::Type::Category::Void:
-        FATAL("void parameter type");
+        SLICER_FATAL("void parameter type");
     }
     code_ir->instructions.insert(first_instr, move);
   }
@@ -356,11 +356,11 @@ void AllocateScratchRegs::ShiftParams(lir::CodeIr* code_ir) {
 
 // Mark [first_reg, first_reg + count) as scratch registers
 void AllocateScratchRegs::Allocate(lir::CodeIr* code_ir, dex::u4 first_reg, int count) {
-  CHECK(count > 0 && count <= left_to_allocate_);
+  SLICER_CHECK(count > 0 && count <= left_to_allocate_);
   code_ir->ir_method->code->registers += count;
   left_to_allocate_ -= count;
   for (int i = 0; i < count; ++i) {
-    CHECK(scratch_regs_.insert(first_reg + i).second);
+    SLICER_CHECK(scratch_regs_.insert(first_reg + i).second);
   }
 }
 
@@ -374,7 +374,7 @@ void AllocateScratchRegs::Allocate(lir::CodeIr* code_ir, dex::u4 first_reg, int
 bool AllocateScratchRegs::Apply(lir::CodeIr* code_ir) {
   const auto code = code_ir->ir_method->code;
   // .dex bytecode allows up to 64k vregs
-  CHECK(code->registers + allocate_count_ <= (1 << 16));
+  SLICER_CHECK(code->registers + allocate_count_ <= (1 << 16));
 
   scratch_regs_.clear();
   left_to_allocate_ = allocate_count_;
@@ -402,7 +402,7 @@ bool AllocateScratchRegs::Apply(lir::CodeIr* code_ir) {
 }
 
 bool MethodInstrumenter::InstrumentMethod(ir::EncodedMethod* ir_method) {
-  CHECK(ir_method != nullptr);
+  SLICER_CHECK(ir_method != nullptr);
   if (ir_method->code == nullptr) {
     // can't instrument abstract methods
     return false;
diff --git a/slicer/reader.cc b/slicer/reader.cc
index 8f23b72..1c547af 100644
--- a/slicer/reader.cc
+++ b/slicer/reader.cc
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-#include "reader.h"
-#include "dex_bytecode.h"
-#include "chronometer.h"
-#include "dex_leb128.h"
+#include "slicer/reader.h"
+#include "slicer/dex_bytecode.h"
+#include "slicer/chronometer.h"
+#include "slicer/dex_leb128.h"
 
 #include <assert.h>
 #include <string.h>
@@ -88,7 +88,7 @@ void Reader::CreateFullIr() {
 
 void Reader::CreateClassIr(dex::u4 index) {
   auto ir_class = GetClass(index);
-  CHECK(ir_class != nullptr);
+  SLICER_CHECK(ir_class != nullptr);
 }
 
 // Returns the index of the class with the specified
@@ -119,102 +119,102 @@ dex::u4 Reader::FindClassIndex(const char* class_descriptor) const {
 //     (we use the dummy value to guard against this too)
 //
 ir::Class* Reader::GetClass(dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   auto& p = dex_ir_->classes_map[index];
   auto dummy = reinterpret_cast<ir::Class*>(1);
   if (p == nullptr) {
     p = dummy;
     auto newClass = ParseClass(index);
-    CHECK(p == dummy);
+    SLICER_CHECK(p == dummy);
     p = newClass;
     dex_ir_->classes_indexes.MarkUsedIndex(index);
   }
-  CHECK(p != dummy);
+  SLICER_CHECK(p != dummy);
   return p;
 }
 
 // map a .dex index to corresponding .dex IR node
 // (see the Reader::GetClass() comments)
 ir::Type* Reader::GetType(dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   auto& p = dex_ir_->types_map[index];
   auto dummy = reinterpret_cast<ir::Type*>(1);
   if (p == nullptr) {
     p = dummy;
     auto newType = ParseType(index);
-    CHECK(p == dummy);
+    SLICER_CHECK(p == dummy);
     p = newType;
     dex_ir_->types_indexes.MarkUsedIndex(index);
   }
-  CHECK(p != dummy);
+  SLICER_CHECK(p != dummy);
   return p;
 }
 
 // map a .dex index to corresponding .dex IR node
 // (see the Reader::GetClass() comments)
 ir::FieldDecl* Reader::GetFieldDecl(dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   auto& p = dex_ir_->fields_map[index];
   auto dummy = reinterpret_cast<ir::FieldDecl*>(1);
   if (p == nullptr) {
     p = dummy;
     auto newField = ParseFieldDecl(index);
-    CHECK(p == dummy);
+    SLICER_CHECK(p == dummy);
     p = newField;
     dex_ir_->fields_indexes.MarkUsedIndex(index);
   }
-  CHECK(p != dummy);
+  SLICER_CHECK(p != dummy);
   return p;
 }
 
 // map a .dex index to corresponding .dex IR node
 // (see the Reader::GetClass() comments)
 ir::MethodDecl* Reader::GetMethodDecl(dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   auto& p = dex_ir_->methods_map[index];
   auto dummy = reinterpret_cast<ir::MethodDecl*>(1);
   if (p == nullptr) {
     p = dummy;
     auto newMethod = ParseMethodDecl(index);
-    CHECK(p == dummy);
+    SLICER_CHECK(p == dummy);
     p = newMethod;
     dex_ir_->methods_indexes.MarkUsedIndex(index);
   }
-  CHECK(p != dummy);
+  SLICER_CHECK(p != dummy);
   return p;
 }
 
 // map a .dex index to corresponding .dex IR node
 // (see the Reader::GetClass() comments)
 ir::Proto* Reader::GetProto(dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   auto& p = dex_ir_->protos_map[index];
   auto dummy = reinterpret_cast<ir::Proto*>(1);
   if (p == nullptr) {
     p = dummy;
     auto newProto = ParseProto(index);
-    CHECK(p == dummy);
+    SLICER_CHECK(p == dummy);
     p = newProto;
     dex_ir_->protos_indexes.MarkUsedIndex(index);
   }
-  CHECK(p != dummy);
+  SLICER_CHECK(p != dummy);
   return p;
 }
 
 // map a .dex index to corresponding .dex IR node
 // (see the Reader::GetClass() comments)
 ir::String* Reader::GetString(dex::u4 index) {
-  CHECK(index != dex::kNoIndex);
+  SLICER_CHECK(index != dex::kNoIndex);
   auto& p = dex_ir_->strings_map[index];
   auto dummy = reinterpret_cast<ir::String*>(1);
   if (p == nullptr) {
     p = dummy;
     auto newString = ParseString(index);
-    CHECK(p == dummy);
+    SLICER_CHECK(p == dummy);
     p = newString;
     dex_ir_->strings_indexes.MarkUsedIndex(index);
   }
-  CHECK(p != dummy);
+  SLICER_CHECK(p != dummy);
   return p;
 }
 
@@ -282,7 +282,7 @@ ir::AnnotationsDirectory* Reader::ExtractAnnotations(dex::u4 offset) {
     return nullptr;
   }
 
-  CHECK(offset % 4 == 0);
+  SLICER_CHECK(offset % 4 == 0);
 
   // first check if we already extracted the same "annotations_directory_item"
   auto& ir_annotations = annotations_directories_[offset];
@@ -312,7 +312,7 @@ ir::AnnotationsDirectory* Reader::ExtractAnnotations(dex::u4 offset) {
 }
 
 ir::Annotation* Reader::ExtractAnnotationItem(dex::u4 offset) {
-  CHECK(offset != 0);
+  SLICER_CHECK(offset != 0);
 
   // first check if we already extracted the same "annotation_item"
   auto& ir_annotation = annotations_[offset];
@@ -330,7 +330,7 @@ ir::AnnotationSet* Reader::ExtractAnnotationSet(dex::u4 offset) {
     return nullptr;
   }
 
-  CHECK(offset % 4 == 0);
+  SLICER_CHECK(offset % 4 == 0);
 
   // first check if we already extracted the same "annotation_set_item"
   auto& ir_annotation_set = annotation_sets_[offset];
@@ -348,7 +348,7 @@ ir::AnnotationSet* Reader::ExtractAnnotationSet(dex::u4 offset) {
 }
 
 ir::AnnotationSetRefList* Reader::ExtractAnnotationSetRefList(dex::u4 offset) {
-  CHECK(offset % 4 == 0);
+  SLICER_CHECK(offset % 4 == 0);
 
   auto dex_annotation_set_ref_list = dataPtr<dex::AnnotationSetRefList>(offset);
   auto ir_annotation_set_ref_list = dex_ir_->Alloc<ir::AnnotationSetRefList>();
@@ -357,7 +357,7 @@ ir::AnnotationSetRefList* Reader::ExtractAnnotationSetRefList(dex::u4 offset) {
     dex::u4 entry_offset = dex_annotation_set_ref_list->list[i].annotations_off;
     if (entry_offset != 0) {
       auto ir_annotation_set = ExtractAnnotationSet(entry_offset);
-      CHECK(ir_annotation_set != nullptr);
+      SLICER_CHECK(ir_annotation_set != nullptr);
       ir_annotation_set_ref_list->annotations.push_back(ir_annotation_set);
     }
   }
@@ -373,7 +373,7 @@ ir::FieldAnnotation* Reader::ParseFieldAnnotation(const dex::u1** pptr) {
 
   ir_field_annotation->annotations =
       ExtractAnnotationSet(dex_field_annotation->annotations_off);
-  CHECK(ir_field_annotation->annotations != nullptr);
+  SLICER_CHECK(ir_field_annotation->annotations != nullptr);
 
   *pptr += sizeof(dex::FieldAnnotationsItem);
   return ir_field_annotation;
@@ -388,7 +388,7 @@ ir::MethodAnnotation* Reader::ParseMethodAnnotation(const dex::u1** pptr) {
 
   ir_method_annotation->annotations =
       ExtractAnnotationSet(dex_method_annotation->annotations_off);
-  CHECK(ir_method_annotation->annotations != nullptr);
+  SLICER_CHECK(ir_method_annotation->annotations != nullptr);
 
   *pptr += sizeof(dex::MethodAnnotationsItem);
   return ir_method_annotation;
@@ -403,7 +403,7 @@ ir::ParamAnnotation* Reader::ParseParamAnnotation(const dex::u1** pptr) {
 
   ir_param_annotation->annotations =
       ExtractAnnotationSetRefList(dex_param_annotation->annotations_off);
-  CHECK(ir_param_annotation->annotations != nullptr);
+  SLICER_CHECK(ir_param_annotation->annotations != nullptr);
 
   *pptr += sizeof(dex::ParameterAnnotationsItem);
   return ir_param_annotation;
@@ -413,9 +413,9 @@ ir::EncodedField* Reader::ParseEncodedField(const dex::u1** pptr, dex::u4* base_
   auto ir_encoded_field = dex_ir_->Alloc<ir::EncodedField>();
 
   auto field_index = dex::ReadULeb128(pptr);
-  CHECK(field_index != dex::kNoIndex);
+  SLICER_CHECK(field_index != dex::kNoIndex);
   if (*base_index != dex::kNoIndex) {
-    CHECK(field_index != 0);
+    SLICER_CHECK(field_index != 0);
     field_index += *base_index;
   }
   *base_index = field_index;
@@ -432,8 +432,8 @@ template <class T>
 static T ParseIntValue(const dex::u1** pptr, size_t size) {
   static_assert(std::is_integral<T>::value, "must be an integral type");
 
-  CHECK(size > 0);
-  CHECK(size <= sizeof(T));
+  SLICER_CHECK(size > 0);
+  SLICER_CHECK(size <= sizeof(T));
 
   T value = 0;
   for (int i = 0; i < size; ++i) {
@@ -453,8 +453,8 @@ static T ParseIntValue(const dex::u1** pptr, size_t size) {
 // (zero-extend to the right)
 template <class T>
 static T ParseFloatValue(const dex::u1** pptr, size_t size) {
-  CHECK(size > 0);
-  CHECK(size <= sizeof(T));
+  SLICER_CHECK(size > 0);
+  SLICER_CHECK(size <= sizeof(T));
 
   T value = 0;
   int start_byte = sizeof(T) - size;
@@ -468,7 +468,7 @@ static T ParseFloatValue(const dex::u1** pptr, size_t size) {
 ir::EncodedValue* Reader::ParseEncodedValue(const dex::u1** pptr) {
   auto ir_encoded_value = dex_ir_->Alloc<ir::EncodedValue>();
 
-  EXTRA(auto base_ptr = *pptr);
+  SLICER_EXTRA(auto base_ptr = *pptr);
 
   dex::u1 header = *(*pptr)++;
   dex::u1 type = header & dex::kEncodedValueTypeMask;
@@ -531,29 +531,29 @@ ir::EncodedValue* Reader::ParseEncodedValue(const dex::u1** pptr) {
     } break;
 
     case dex::kEncodedArray:
-      CHECK(arg == 0);
+      SLICER_CHECK(arg == 0);
       ir_encoded_value->u.array_value = ParseEncodedArray(pptr);
       break;
 
     case dex::kEncodedAnnotation:
-      CHECK(arg == 0);
+      SLICER_CHECK(arg == 0);
       ir_encoded_value->u.annotation_value = ParseAnnotation(pptr);
       break;
 
     case dex::kEncodedNull:
-      CHECK(arg == 0);
+      SLICER_CHECK(arg == 0);
       break;
 
     case dex::kEncodedBoolean:
-      CHECK(arg < 2);
+      SLICER_CHECK(arg < 2);
       ir_encoded_value->u.bool_value = (arg == 1);
       break;
 
     default:
-      CHECK(!"unexpected value type");
+      SLICER_CHECK(!"unexpected value type");
   }
 
-  EXTRA(ir_encoded_value->original = slicer::MemView(base_ptr, *pptr - base_ptr));
+  SLICER_EXTRA(ir_encoded_value->original = slicer::MemView(base_ptr, *pptr - base_ptr));
 
   return ir_encoded_value;
 }
@@ -703,7 +703,7 @@ ir::Code* Reader::ExtractCode(dex::u4 offset) {
     return nullptr;
   }
 
-  CHECK(offset % 4 == 0);
+  SLICER_CHECK(offset % 4 == 0);
 
   auto dex_code = dataPtr<dex::Code>(offset);
   auto ir_code = dex_ir_->Alloc<ir::Code>();
@@ -738,7 +738,7 @@ ir::Code* Reader::ExtractCode(dex::u4 offset) {
     auto ptr = handlers_list;
 
     dex::u4 handlers_count = dex::ReadULeb128(&ptr);
-    WEAK_CHECK(handlers_count <= dex_code->tries_size);
+    SLICER_WEAK_CHECK(handlers_count <= dex_code->tries_size);
 
     for (dex::u4 handler_index = 0; handler_index < handlers_count; ++handler_index) {
       int catch_count = dex::ReadSLeb128(&ptr);
@@ -769,9 +769,9 @@ ir::EncodedMethod* Reader::ParseEncodedMethod(const dex::u1** pptr, dex::u4* bas
   auto ir_encoded_method = dex_ir_->Alloc<ir::EncodedMethod>();
 
   auto method_index = dex::ReadULeb128(pptr);
-  CHECK(method_index != dex::kNoIndex);
+  SLICER_CHECK(method_index != dex::kNoIndex);
   if (*base_index != dex::kNoIndex) {
-    CHECK(method_index != 0);
+    SLICER_CHECK(method_index != 0);
     method_index += *base_index;
   }
   *base_index = method_index;
@@ -833,7 +833,7 @@ ir::TypeList* Reader::ExtractTypeList(dex::u4 offset) {
     ir_type_list = dex_ir_->Alloc<ir::TypeList>();
 
     auto dex_type_list = dataPtr<dex::TypeList>(offset);
-    WEAK_CHECK(dex_type_list->size > 0);
+    SLICER_WEAK_CHECK(dex_type_list->size > 0);
 
     for (dex::u4 i = 0; i < dex_type_list->size; ++i) {
       ir_type_list->types.push_back(GetType(dex_type_list->list[i].type_idx));
@@ -920,59 +920,59 @@ void Reader::ParseInstructions(slicer::ArrayView<const dex::u2> code) {
     }
 
     auto isize = dex::GetWidthFromBytecode(ptr);
-    CHECK(isize > 0);
+    SLICER_CHECK(isize > 0);
     ptr += isize;
   }
-  CHECK(ptr == code.end());
+  SLICER_CHECK(ptr == code.end());
 }
 
 // Basic .dex header structural checks
 void Reader::ValidateHeader() {
-  CHECK(size_ > sizeof(dex::Header));
+  SLICER_CHECK(size_ > sizeof(dex::Header));
 
   // Known issue: For performance reasons the initial size_ passed to jvmti events might be an
   // estimate. b/72402467
-  CHECK(header_->file_size <= size_);
-  CHECK(header_->header_size == sizeof(dex::Header));
-  CHECK(header_->endian_tag == dex::kEndianConstant);
-  CHECK(header_->data_size % 4 == 0);
+  SLICER_CHECK(header_->file_size <= size_);
+  SLICER_CHECK(header_->header_size == sizeof(dex::Header));
+  SLICER_CHECK(header_->endian_tag == dex::kEndianConstant);
+  SLICER_CHECK(header_->data_size % 4 == 0);
 
   // Known issue: The fields might be slighly corrupted b/65452964
-  // CHECK(header_->data_off + header_->data_size <= size_);
-
-  CHECK(header_->string_ids_off % 4 == 0);
-  CHECK(header_->type_ids_size < 65536);
-  CHECK(header_->type_ids_off % 4 == 0);
-  CHECK(header_->proto_ids_size < 65536);
-  CHECK(header_->proto_ids_off % 4 == 0);
-  CHECK(header_->field_ids_off % 4 == 0);
-  CHECK(header_->method_ids_off % 4 == 0);
-  CHECK(header_->class_defs_off % 4 == 0);
-  CHECK(header_->map_off >= header_->data_off && header_->map_off < size_);
-  CHECK(header_->link_size == 0);
-  CHECK(header_->link_off == 0);
-  CHECK(header_->data_off % 4 == 0);
-  CHECK(header_->map_off % 4 == 0);
+  // SLICER_CHECK(header_->data_off + header_->data_size <= size_);
+
+  SLICER_CHECK(header_->string_ids_off % 4 == 0);
+  SLICER_CHECK(header_->type_ids_size < 65536);
+  SLICER_CHECK(header_->type_ids_off % 4 == 0);
+  SLICER_CHECK(header_->proto_ids_size < 65536);
+  SLICER_CHECK(header_->proto_ids_off % 4 == 0);
+  SLICER_CHECK(header_->field_ids_off % 4 == 0);
+  SLICER_CHECK(header_->method_ids_off % 4 == 0);
+  SLICER_CHECK(header_->class_defs_off % 4 == 0);
+  SLICER_CHECK(header_->map_off >= header_->data_off && header_->map_off < size_);
+  SLICER_CHECK(header_->link_size == 0);
+  SLICER_CHECK(header_->link_off == 0);
+  SLICER_CHECK(header_->data_off % 4 == 0);
+  SLICER_CHECK(header_->map_off % 4 == 0);
 
   // we seem to have .dex files with extra bytes at the end ...
   // Known issue: For performance reasons the initial size_ passed to jvmti events might be an
   // estimate. b/72402467
-  WEAK_CHECK(header_->data_off + header_->data_size <= size_);
+  SLICER_WEAK_CHECK(header_->data_off + header_->data_size <= size_);
 
   // but we should still have the whole data section
 
   // Known issue: The fields might be slighly corrupted b/65452964
   // Known issue: For performance reasons the initial size_ passed to jvmti events might be an
   // estimate. b/72402467
-  // CHECK(header_->data_off + header_->data_size <= size_);
+  // SLICER_CHECK(header_->data_off + header_->data_size <= size_);
 
   // validate the map
   // (map section size = sizeof(MapList::size) + sizeof(MapList::list[size])
   auto map_list = ptr<dex::MapList>(header_->map_off);
-  CHECK(map_list->size > 0);
+  SLICER_CHECK(map_list->size > 0);
   auto map_section_size =
       sizeof(dex::u4) + sizeof(dex::MapItem) * map_list->size;
-  CHECK(header_->map_off + map_section_size <= size_);
+  SLICER_CHECK(header_->map_off + map_section_size <= size_);
 }
 
 }  // namespace dex
diff --git a/slicer/tryblocks_encoder.cc b/slicer/tryblocks_encoder.cc
index b1c9a8e..547e9d0 100644
--- a/slicer/tryblocks_encoder.cc
+++ b/slicer/tryblocks_encoder.cc
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#include "tryblocks_encoder.h"
-#include "chronometer.h"
-#include "common.h"
+#include "slicer/tryblocks_encoder.h"
+#include "slicer/chronometer.h"
+#include "slicer/common.h"
 
 #include <assert.h>
 
@@ -25,8 +25,8 @@ namespace lir {
 bool TryBlocksEncoder::Visit(TryBlockEnd* try_end) {
   const dex::u4 begin_offset = try_end->try_begin->offset;
   const dex::u4 end_offset = try_end->offset;
-  CHECK(end_offset > begin_offset);
-  CHECK(end_offset - begin_offset < (1 << 16));
+  SLICER_CHECK(end_offset > begin_offset);
+  SLICER_CHECK(end_offset - begin_offset < (1 << 16));
 
   // generate the "try_item"
   dex::TryBlock try_block = {};
@@ -43,12 +43,12 @@ bool TryBlocksEncoder::Visit(TryBlockEnd* try_end) {
     // type_idx
     handlers_.PushULeb128(handler.ir_type->orig_index);
     // address
-    CHECK(handler.label->offset != kInvalidOffset);
+    SLICER_CHECK(handler.label->offset != kInvalidOffset);
     handlers_.PushULeb128(handler.label->offset);
   }
   if (try_end->catch_all != nullptr) {
     // address
-    CHECK(try_end->catch_all->offset != kInvalidOffset);
+    SLICER_CHECK(try_end->catch_all->offset != kInvalidOffset);
     handlers_.PushULeb128(try_end->catch_all->offset);
   }
 
@@ -56,8 +56,8 @@ bool TryBlocksEncoder::Visit(TryBlockEnd* try_end) {
 }
 
 void TryBlocksEncoder::Encode(ir::Code* ir_code, std::shared_ptr<ir::DexFile> dex_ir) {
-  CHECK(handlers_.empty());
-  CHECK(tries_.empty());
+  SLICER_CHECK(handlers_.empty());
+  SLICER_CHECK(tries_.empty());
 
   // first, count the number of try blocks
   int tries_count = 0;
@@ -66,7 +66,7 @@ void TryBlocksEncoder::Encode(ir::Code* ir_code, std::shared_ptr<ir::DexFile> de
       ++tries_count;
     }
   }
-  CHECK(tries_count < (1 << 16));
+  SLICER_CHECK(tries_count < (1 << 16));
 
   // no try blocks?
   if (tries_count == 0) {
@@ -91,8 +91,8 @@ void TryBlocksEncoder::Encode(ir::Code* ir_code, std::shared_ptr<ir::DexFile> de
   for (auto instr : instructions_) {
     instr->Accept(this);
   }
-  CHECK(!tries_.empty());
-  CHECK(!handlers_.empty());
+  SLICER_CHECK(!tries_.empty());
+  SLICER_CHECK(!handlers_.empty());
   tries_.Seal(1);
   handlers_.Seal(1);
 
diff --git a/slicer/writer.cc b/slicer/writer.cc
index 1b55577..3361c70 100644
--- a/slicer/writer.cc
+++ b/slicer/writer.cc
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-#include "writer.h"
-#include "common.h"
-#include "scopeguard.h"
-#include "dex_bytecode.h"
-#include "dex_format.h"
-#include "dex_ir.h"
-#include "dex_leb128.h"
+#include "slicer/writer.h"
+#include "slicer/common.h"
+#include "slicer/scopeguard.h"
+#include "slicer/dex_bytecode.h"
+#include "slicer/dex_format.h"
+#include "slicer/dex_ir.h"
+#include "slicer/dex_leb128.h"
 
 #include <assert.h>
 #include <type_traits>
@@ -99,7 +99,7 @@ static void WriteAnnotation(const ir::Annotation* ir_annotation, Section& data);
 
 // "encoded_value"
 static void WriteEncodedValue(const ir::EncodedValue* ir_value, Section& data) {
-  EXTRA(auto offset = data.size());
+  SLICER_EXTRA(auto offset = data.size());
 
   dex::u1 type = ir_value->type;
   switch (type) {
@@ -171,12 +171,12 @@ static void WriteEncodedValue(const ir::EncodedValue* ir_value, Section& data) {
     } break;
 
     default:
-      CHECK(!"unexpected value type");
+      SLICER_CHECK(!"unexpected value type");
   }
 
   // optionally check the encoding against the original one
   // (if possible, some of the values contain relocated indexes)
-  EXTRA({
+  SLICER_EXTRA({
     switch (type) {
       case dex::kEncodedByte:
       case dex::kEncodedShort:
@@ -189,8 +189,8 @@ static void WriteEncodedValue(const ir::EncodedValue* ir_value, Section& data) {
       case dex::kEncodedBoolean:
         auto ptr = data.ptr<const dex::u1>(offset);
         auto size = data.size() - offset;
-        CHECK(size == ir_value->original.size());
-        CHECK(memcmp(ptr, ir_value->original.ptr(), size) == 0);
+        SLICER_CHECK(size == ir_value->original.size());
+        SLICER_CHECK(memcmp(ptr, ir_value->original.ptr(), size) == 0);
         break;
     }
   });
@@ -219,15 +219,15 @@ static void WriteEncodedArray(const ir::EncodedArray* ir_array, Section& data) {
 template <class T>
 static void CopySection(const T& section, dex::u1* image, dex::u4 image_size) {
   if (section.size() == 0) {
-    CHECK(section.ItemsCount() == 0);
+    SLICER_CHECK(section.ItemsCount() == 0);
     return;
   }
 
-  CHECK(section.ItemsCount() > 0);
+  SLICER_CHECK(section.ItemsCount() > 0);
   dex::u4 offset = section.SectionOffset();
   dex::u4 size = section.size();
-  CHECK(offset >= sizeof(dex::Header));
-  CHECK(offset + size <= image_size);
+  SLICER_CHECK(offset >= sizeof(dex::Header));
+  SLICER_CHECK(offset + size <= image_size);
 
   ::memcpy(image + offset, section.data(), size);
 }
@@ -238,7 +238,7 @@ dex::u1* Writer::CreateImage(Allocator* allocator, size_t* new_image_size) {
   // create a new DexImage
   dex_.reset(new DexImage);
 
-  SCOPE_EXIT {
+  SLICER_SCOPE_EXIT {
       dex_.reset();
   };
 
@@ -260,7 +260,7 @@ dex::u1* Writer::CreateImage(Allocator* allocator, size_t* new_image_size) {
   offset += dex_->class_defs.Init(offset, dex_ir_->classes.size());
 
   // the base offset for the "data" meta-section
-  CHECK(offset % 4 == 0);
+  SLICER_CHECK(offset % 4 == 0);
   const dex::u4 data_offset = offset;
 
   // we must create the sections in a very specific
@@ -285,7 +285,7 @@ dex::u1* Writer::CreateImage(Allocator* allocator, size_t* new_image_size) {
   FillClassDefs();
 
   // allocate the final buffer for the .dex image
-  CHECK(offset % 4 == 0);
+  SLICER_CHECK(offset % 4 == 0);
   const dex::u4 image_size = offset;
   dex::u1* image = static_cast<dex::u1*>(allocator->Allocate(image_size));
   if (image == nullptr) {
@@ -295,7 +295,7 @@ dex::u1* Writer::CreateImage(Allocator* allocator, size_t* new_image_size) {
   memset(image, 0, image_size);
 
   // finally, back-fill the header
-  CHECK(image_size > sizeof(dex::Header));
+  SLICER_CHECK(image_size > sizeof(dex::Header));
 
   dex::Header* header = reinterpret_cast<dex::Header*>(image + 0);
 
@@ -374,7 +374,7 @@ dex::u4 Writer::CreateStringDataSection(dex::u4 section_offset) {
 template <class T>
 static void AddMapItem(const T& section, std::vector<dex::MapItem>& items) {
   if (section.ItemsCount() > 0) {
-    CHECK(section.SectionOffset() >= sizeof(dex::Header));
+    SLICER_CHECK(section.SectionOffset() >= sizeof(dex::Header));
     dex::MapItem map_item = {};
     map_item.type = section.MapEntryType();
     map_item.size = section.ItemsCount();
@@ -417,7 +417,7 @@ dex::u4 Writer::CreateMapSection(dex::u4 section_offset) {
 
   std::sort(map_items.begin(), map_items.end(),
             [](const dex::MapItem& a, const dex::MapItem& b) {
-              CHECK(a.offset != b.offset);
+              SLICER_CHECK(a.offset != b.offset);
               return a.offset < b.offset;
             });
 
@@ -434,7 +434,7 @@ dex::u4 Writer::CreateAnnItemSection(dex::u4 section_offset) {
     if (ir_node->visibility != dex::kVisibilityEncoded) {
       // TODO: factor out the node_offset_ updating
       dex::u4& offset = node_offset_[ir_node.get()];
-      CHECK(offset == 0);
+      SLICER_CHECK(offset == 0);
       offset = WriteAnnotationItem(ir_node.get());
     }
   }
@@ -448,7 +448,7 @@ dex::u4 Writer::CreateAnnSetsSection(dex::u4 section_offset) {
 
   for (const auto& ir_node : dex_ir_->annotation_sets) {
     dex::u4& offset = node_offset_[ir_node.get()];
-    CHECK(offset == 0);
+    SLICER_CHECK(offset == 0);
     offset = WriteAnnotationSet(ir_node.get());
   }
 
@@ -461,7 +461,7 @@ dex::u4 Writer::CreateAnnSetRefListsSection(dex::u4 section_offset) {
 
   for (const auto& ir_node : dex_ir_->annotation_set_ref_lists) {
     dex::u4& offset = node_offset_[ir_node.get()];
-    CHECK(offset == 0);
+    SLICER_CHECK(offset == 0);
     offset = WriteAnnotationSetRefList(ir_node.get());
   }
 
@@ -474,7 +474,7 @@ dex::u4 Writer::CreateTypeListsSection(dex::u4 section_offset) {
 
   for (const auto& ir_type_list : dex_ir_->type_lists) {
     dex::u4& offset = node_offset_[ir_type_list.get()];
-    CHECK(offset == 0);
+    SLICER_CHECK(offset == 0);
     offset = WriteTypeList(ir_type_list->types);
   }
 
@@ -487,7 +487,7 @@ dex::u4 Writer::CreateCodeItemSection(dex::u4 section_offset) {
 
   for (const auto& ir_node : dex_ir_->code) {
     dex::u4& offset = node_offset_[ir_node.get()];
-    CHECK(offset == 0);
+    SLICER_CHECK(offset == 0);
     offset = WriteCode(ir_node.get());
   }
 
@@ -501,7 +501,7 @@ dex::u4 Writer::CreateDebugInfoSection(dex::u4 section_offset) {
 
   for (const auto& ir_node : dex_ir_->debug_info) {
     dex::u4& offset = node_offset_[ir_node.get()];
-    CHECK(offset == 0);
+    SLICER_CHECK(offset == 0);
     offset = WriteDebugInfo(ir_node.get());
   }
 
@@ -637,7 +637,7 @@ dex::u4 Writer::WriteTypeList(const std::vector<ir::Type*>& types) {
 
 // "annotation_item"
 dex::u4 Writer::WriteAnnotationItem(const ir::Annotation* ir_annotation) {
-  CHECK(ir_annotation->visibility != dex::kVisibilityEncoded);
+  SLICER_CHECK(ir_annotation->visibility != dex::kVisibilityEncoded);
 
   auto& data = dex_->ann_items;
   dex::u4 offset = data.AddItem();
@@ -648,7 +648,7 @@ dex::u4 Writer::WriteAnnotationItem(const ir::Annotation* ir_annotation) {
 
 // "annotation_set_item"
 dex::u4 Writer::WriteAnnotationSet(const ir::AnnotationSet* ir_annotation_set) {
-  CHECK(ir_annotation_set != nullptr);
+  SLICER_CHECK(ir_annotation_set != nullptr);
 
   const auto& annotations = ir_annotation_set->annotations;
 
@@ -664,7 +664,7 @@ dex::u4 Writer::WriteAnnotationSet(const ir::AnnotationSet* ir_annotation_set) {
 // "annotation_set_ref_list"
 dex::u4 Writer::WriteAnnotationSetRefList(
     const ir::AnnotationSetRefList* ir_annotation_set_ref_list) {
-  CHECK(ir_annotation_set_ref_list != nullptr);
+  SLICER_CHECK(ir_annotation_set_ref_list != nullptr);
 
   const auto& annotations = ir_annotation_set_ref_list->annotations;
 
@@ -740,7 +740,7 @@ dex::u4 Writer::WriteClassAnnotations(const ir::Class* ir_class) {
 
 // "debug_info_item"
 dex::u4 Writer::WriteDebugInfo(const ir::DebugInfo* ir_debug_info) {
-  CHECK(ir_debug_info != nullptr);
+  SLICER_CHECK(ir_debug_info != nullptr);
 
   auto& data = dex_->debug_info;
   dex::u4 offset = data.AddItem();
@@ -813,7 +813,7 @@ dex::u4 Writer::WriteDebugInfo(const ir::DebugInfo* ir_debug_info) {
 
 // instruction[] array
 void Writer::WriteInstructions(slicer::ArrayView<const dex::u2> instructions) {
-  CHECK(!instructions.empty());
+  SLICER_CHECK(!instructions.empty());
 
   auto offset = dex_->code.Push(instructions);
   dex::u2* ptr = dex_->code.ptr<dex::u2>(offset);
@@ -846,39 +846,39 @@ void Writer::WriteInstructions(slicer::ArrayView<const dex::u2> instructions) {
     switch (dex::GetIndexTypeFromOpcode(opcode)) {
       case dex::kIndexStringRef:
         if (index32 != nullptr) {
-          CHECK(index16 == nullptr);
+          SLICER_CHECK(index16 == nullptr);
           dex::u4 new_index = MapStringIndex(*index32);
-          CHECK(new_index != dex::kNoIndex);
+          SLICER_CHECK(new_index != dex::kNoIndex);
           *index32 = new_index;
         } else {
           dex::u4 new_index = MapStringIndex(*index16);
-          CHECK(new_index != dex::kNoIndex);
-          CHECK(dex::u2(new_index) == new_index);
+          SLICER_CHECK(new_index != dex::kNoIndex);
+          SLICER_CHECK(dex::u2(new_index) == new_index);
           *index16 = dex::u2(new_index);
         }
         break;
 
       case dex::kIndexTypeRef: {
-        CHECK(index32 == nullptr);
+        SLICER_CHECK(index32 == nullptr);
         dex::u4 new_index = MapTypeIndex(*index16);
-        CHECK(new_index != dex::kNoIndex);
-        CHECK(dex::u2(new_index) == new_index);
+        SLICER_CHECK(new_index != dex::kNoIndex);
+        SLICER_CHECK(dex::u2(new_index) == new_index);
         *index16 = dex::u2(new_index);
       } break;
 
       case dex::kIndexFieldRef: {
-        CHECK(index32 == nullptr);
+        SLICER_CHECK(index32 == nullptr);
         dex::u4 new_index = MapFieldIndex(*index16);
-        CHECK(new_index != dex::kNoIndex);
-        CHECK(dex::u2(new_index) == new_index);
+        SLICER_CHECK(new_index != dex::kNoIndex);
+        SLICER_CHECK(dex::u2(new_index) == new_index);
         *index16 = dex::u2(new_index);
       } break;
 
       case dex::kIndexMethodRef: {
-        CHECK(index32 == nullptr);
+        SLICER_CHECK(index32 == nullptr);
         dex::u4 new_index = MapMethodIndex(*index16);
-        CHECK(new_index != dex::kNoIndex);
-        CHECK(dex::u2(new_index) == new_index);
+        SLICER_CHECK(new_index != dex::kNoIndex);
+        SLICER_CHECK(dex::u2(new_index) == new_index);
         *index16 = dex::u2(new_index);
       } break;
 
@@ -887,15 +887,15 @@ void Writer::WriteInstructions(slicer::ArrayView<const dex::u2> instructions) {
     }
 
     auto isize = dex::GetWidthFromBytecode(ptr);
-    CHECK(isize > 0);
+    SLICER_CHECK(isize > 0);
     ptr += isize;
   }
-  CHECK(ptr == end);
+  SLICER_CHECK(ptr == end);
 }
 
 // "try_item[] + encoded_catch_handler_list"
 void Writer::WriteTryBlocks(const ir::Code* irCode) {
-  CHECK(!irCode->try_blocks.empty());
+  SLICER_CHECK(!irCode->try_blocks.empty());
 
   // use a temporary buffer to build the "encoded_catch_handler_list"
   slicer::Buffer handlers_list;
@@ -941,14 +941,14 @@ void Writer::WriteTryBlocks(const ir::Code* irCode) {
   for (dex::TryBlock& dex_try : slicer::ArrayView<dex::TryBlock>(
            data.ptr<dex::TryBlock>(tries_offset), irCode->try_blocks.size())) {
     dex::u2 new_Handler_offset = handlers_offset_map[dex_try.handler_off];
-    CHECK(new_Handler_offset != 0);
+    SLICER_CHECK(new_Handler_offset != 0);
     dex_try.handler_off = new_Handler_offset;
   }
 }
 
 // "code_item"
 dex::u4 Writer::WriteCode(const ir::Code* irCode) {
-  CHECK(irCode != nullptr);
+  SLICER_CHECK(irCode != nullptr);
 
   dex::Code dex_code = {};
   dex_code.registers_size = irCode->registers;
@@ -973,9 +973,9 @@ dex::u4 Writer::WriteCode(const ir::Code* irCode) {
 void Writer::WriteEncodedField(const ir::EncodedField* ir_encoded_field,
                        dex::u4* base_index) {
   dex::u4 index_delta = ir_encoded_field->decl->index;
-  CHECK(index_delta != dex::kNoIndex);
+  SLICER_CHECK(index_delta != dex::kNoIndex);
   if (*base_index != dex::kNoIndex) {
-    CHECK(index_delta > *base_index);
+    SLICER_CHECK(index_delta > *base_index);
     index_delta = index_delta - *base_index;
   }
   *base_index = ir_encoded_field->decl->index;
@@ -989,9 +989,9 @@ void Writer::WriteEncodedField(const ir::EncodedField* ir_encoded_field,
 void Writer::WriteEncodedMethod(const ir::EncodedMethod* ir_encoded_method,
                         dex::u4* base_index) {
   dex::u4 index_delta = ir_encoded_method->decl->index;
-  CHECK(index_delta != dex::kNoIndex);
+  SLICER_CHECK(index_delta != dex::kNoIndex);
   if (*base_index != dex::kNoIndex) {
-    CHECK(index_delta > *base_index);
+    SLICER_CHECK(index_delta > *base_index);
     index_delta = index_delta - *base_index;
   }
   *base_index = ir_encoded_method->decl->index;
@@ -1062,7 +1062,7 @@ dex::u4 Writer::WriteClassStaticValues(const ir::Class* ir_class) {
 dex::u4 Writer::MapStringIndex(dex::u4 index) const {
   if (index != dex::kNoIndex) {
     index = dex_ir_->strings_map.at(index)->index;
-    CHECK(index != dex::kNoIndex);
+    SLICER_CHECK(index != dex::kNoIndex);
   }
   return index;
 }
@@ -1071,7 +1071,7 @@ dex::u4 Writer::MapStringIndex(dex::u4 index) const {
 dex::u4 Writer::MapTypeIndex(dex::u4 index) const {
   if (index != dex::kNoIndex) {
     index = dex_ir_->types_map.at(index)->index;
-    CHECK(index != dex::kNoIndex);
+    SLICER_CHECK(index != dex::kNoIndex);
   }
   return index;
 }
@@ -1080,7 +1080,7 @@ dex::u4 Writer::MapTypeIndex(dex::u4 index) const {
 dex::u4 Writer::MapFieldIndex(dex::u4 index) const {
   if (index != dex::kNoIndex) {
     index = dex_ir_->fields_map.at(index)->index;
-    CHECK(index != dex::kNoIndex);
+    SLICER_CHECK(index != dex::kNoIndex);
   }
   return index;
 }
@@ -1089,7 +1089,7 @@ dex::u4 Writer::MapFieldIndex(dex::u4 index) const {
 dex::u4 Writer::MapMethodIndex(dex::u4 index) const {
   if (index != dex::kNoIndex) {
     index = dex_ir_->methods_map.at(index)->index;
-    CHECK(index != dex::kNoIndex);
+    SLICER_CHECK(index != dex::kNoIndex);
   }
   return index;
 }
@@ -1100,9 +1100,9 @@ dex::u4 Writer::FilePointer(const ir::Node* ir_node) const {
     return 0;
   }
   auto it = node_offset_.find(ir_node);
-  CHECK(it != node_offset_.end());
+  SLICER_CHECK(it != node_offset_.end());
   dex::u4 offset = it->second;
-  CHECK(offset > 0);
+  SLICER_CHECK(offset > 0);
   return offset;
 }