diff --git a/src/cc/frontends/b/loader.cc b/src/cc/frontends/b/loader.cc
index 8d7f8a2f..4f6086ca 100644
--- a/src/cc/frontends/b/loader.cc
+++ b/src/cc/frontends/b/loader.cc
@@ -36,14 +36,14 @@ int BLoader::parse(llvm::Module *mod, const string &filename, const string &prot
                    TableStorage &ts, const string &id, const std::string &maps_ns) {
   int rc;
 
-  proto_parser_ = make_unique<ebpf::cc::Parser>(proto_filename);
+  proto_parser_ = ebpf::make_unique<ebpf::cc::Parser>(proto_filename);
   rc = proto_parser_->parse();
   if (rc) {
     fprintf(stderr, "In file: %s\n", filename.c_str());
     return rc;
   }
 
-  parser_ = make_unique<ebpf::cc::Parser>(filename);
+  parser_ = ebpf::make_unique<ebpf::cc::Parser>(filename);
   rc = parser_->parse();
   if (rc) {
     fprintf(stderr, "In file: %s\n", filename.c_str());
diff --git a/src/cc/frontends/b/parser.yy b/src/cc/frontends/b/parser.yy
index 527e84f4..edb0fea1 100644
--- a/src/cc/frontends/b/parser.yy
+++ b/src/cc/frontends/b/parser.yy
@@ -396,7 +396,7 @@ onvalid_stmt
 
 switch_stmt
   : TSWITCH expr TLBRACE case_stmts TRBRACE
-    { $$ = new SwitchStmtNode(ExprNode::Ptr($2), make_unique<BlockStmtNode>(move(*$4))); delete $4;
+    { $$ = new SwitchStmtNode(ExprNode::Ptr($2), ebpf::make_unique<BlockStmtNode>(move(*$4))); delete $4;
       parser.set_loc($$, @$); }
   ;
 
diff --git a/src/cc/frontends/b/type_check.cc b/src/cc/frontends/b/type_check.cc
index 7c5b7ce5..f0613e01 100644
--- a/src/cc/frontends/b/type_check.cc
+++ b/src/cc/frontends/b/type_check.cc
@@ -259,7 +259,7 @@ StatusTuple TypeCheck::check_lookup_method(MethodCallExprNode *n) {
   if (table->type_id()->name_ == "LPM")
     return mkstatus_(n, "LPM unsupported");
   if (n->block_->scope_) {
-    auto result = make_unique<StructVariableDeclStmtNode>(table->leaf_id()->copy(), make_unique<IdentExprNode>("_result"),
+    auto result = ebpf::make_unique<StructVariableDeclStmtNode>(table->leaf_id()->copy(), ebpf::make_unique<IdentExprNode>("_result"),
                                                           VariableDeclStmtNode::STRUCT_REFERENCE);
     n->block_->scope_->add("_result", result.get());
     n->block_->stmts_.insert(n->block_->stmts_.begin(), move(result));
@@ -389,9 +389,9 @@ StatusTuple TypeCheck::visit_struct_variable_decl_stmt_node(StructVariableDeclSt
     }
     for (auto f = type->stmts_.begin(); f != type->stmts_.end(); ++f) {
       if (used.find((*f)->id_->name_) == used.end()) {
-        auto id = make_unique<IdentExprNode>(n->id_->name_);
+        auto id = ebpf::make_unique<IdentExprNode>(n->id_->name_);
         id->append_dot((*f)->id_->name_);
-        n->init_.push_back(make_unique<AssignExprNode>(move(id), make_unique<IntegerExprNode>("0")));
+        n->init_.push_back(ebpf::make_unique<AssignExprNode>(move(id), ebpf::make_unique<IntegerExprNode>("0")));
       }
     }
 
@@ -429,8 +429,8 @@ StatusTuple TypeCheck::visit_state_decl_stmt_node(StateDeclStmtNode *n) {
   auto s1 = proto_scopes_->top_state()->lookup(n->id_->name_, true);
   if (s1) {
     const string &name = n->id_->name_;
-    auto offset_var = make_unique<IntegerVariableDeclStmtNode>(make_unique<IdentExprNode>("$" + name), "64");
-    offset_var->init_.push_back(make_unique<AssignExprNode>(offset_var->id_->copy(), make_unique<IntegerExprNode>("0")));
+    auto offset_var = ebpf::make_unique<IntegerVariableDeclStmtNode>(ebpf::make_unique<IdentExprNode>("$" + name), "64");
+    offset_var->init_.push_back(ebpf::make_unique<AssignExprNode>(offset_var->id_->copy(), ebpf::make_unique<IntegerExprNode>("0")));
     scopes_->current_var()->add("$" + name, offset_var.get());
     s1->subs_[0].block_->scope_->add("$" + name, offset_var.get());
     n->init_.push_back(move(offset_var));
@@ -443,13 +443,13 @@ StatusTuple TypeCheck::visit_state_decl_stmt_node(StateDeclStmtNode *n) {
     if (!p) return mkstatus_(n, "unable to find struct decl for parser state %s", n->id_->full_name().c_str());
 
     // $proto = parsed_bytes; parsed_bytes += sizeof($proto);
-    auto asn1 = make_unique<AssignExprNode>(make_unique<IdentExprNode>("$" + n->id_->name_),
-                                            make_unique<IdentExprNode>("parsed_bytes"));
-    n->init_.push_back(make_unique<ExprStmtNode>(move(asn1)));
-    auto add_expr = make_unique<BinopExprNode>(make_unique<IdentExprNode>("parsed_bytes"), Tok::TPLUS,
-                                               make_unique<IntegerExprNode>(std::to_string(p->bit_width_ >> 3), 64));
-    auto asn2 = make_unique<AssignExprNode>(make_unique<IdentExprNode>("parsed_bytes"), move(add_expr));
-    n->init_.push_back(make_unique<ExprStmtNode>(move(asn2)));
+    auto asn1 = ebpf::make_unique<AssignExprNode>(ebpf::make_unique<IdentExprNode>("$" + n->id_->name_),
+                                            ebpf::make_unique<IdentExprNode>("parsed_bytes"));
+    n->init_.push_back(ebpf::make_unique<ExprStmtNode>(move(asn1)));
+    auto add_expr = ebpf::make_unique<BinopExprNode>(ebpf::make_unique<IdentExprNode>("parsed_bytes"), Tok::TPLUS,
+                                               ebpf::make_unique<IntegerExprNode>(std::to_string(p->bit_width_ >> 3), 64));
+    auto asn2 = ebpf::make_unique<AssignExprNode>(ebpf::make_unique<IdentExprNode>("parsed_bytes"), move(add_expr));
+    n->init_.push_back(ebpf::make_unique<ExprStmtNode>(move(asn2)));
   }
 
   for (auto it = n->init_.begin(); it != n->init_.end(); ++it) {
@@ -552,23 +552,23 @@ StatusTuple TypeCheck::visit(Node *root) {
   // if (scopes_->top_struct()->lookup("_skbuff", true)) {
   //   return StatusTuple(-1, "_skbuff already defined");
   // }
-  // auto skb_type = make_unique<StructDeclStmtNode>(make_unique<IdentExprNode>("_skbuff"));
+  // auto skb_type = ebpf::make_unique<StructDeclStmtNode>(ebpf::make_unique<IdentExprNode>("_skbuff"));
   // scopes_->top_struct()->add("_skbuff", skb_type.get());
   // b->stmts_.push_back(move(skb_type));
 
   // if (scopes_->current_var()->lookup("skb", true)) {
   //   return StatusTuple(-1, "skb already defined");
   // }
-  // auto skb = make_unique<StructVariableDeclStmtNode>(make_unique<IdentExprNode>("_skbuff"),
-  //                                                    make_unique<IdentExprNode>("skb"));
+  // auto skb = ebpf::make_unique<StructVariableDeclStmtNode>(ebpf::make_unique<IdentExprNode>("_skbuff"),
+  //                                                    ebpf::make_unique<IdentExprNode>("skb"));
   // skb->storage_type_ = VariableDeclStmtNode::STRUCT_REFERENCE;
   // scopes_->current_var()->add("skb", skb.get());
   // b->stmts_.push_back(move(skb));
 
   // offset counter
-  auto parsed_bytes = make_unique<IntegerVariableDeclStmtNode>(
-                        make_unique<IdentExprNode>("parsed_bytes"), "64");
-  parsed_bytes->init_.push_back(make_unique<AssignExprNode>(parsed_bytes->id_->copy(), make_unique<IntegerExprNode>("0")));
+  auto parsed_bytes = ebpf::make_unique<IntegerVariableDeclStmtNode>(
+                        ebpf::make_unique<IdentExprNode>("parsed_bytes"), "64");
+  parsed_bytes->init_.push_back(ebpf::make_unique<AssignExprNode>(parsed_bytes->id_->copy(), ebpf::make_unique<IntegerExprNode>("0")));
   scopes_->current_var()->add("parsed_bytes", parsed_bytes.get());
   b->stmts_.push_back(move(parsed_bytes));
 
diff --git a/src/cc/shared_table.cc b/src/cc/shared_table.cc
index 29744a5d..bc2e0904 100644
--- a/src/cc/shared_table.cc
+++ b/src/cc/shared_table.cc
@@ -36,7 +36,7 @@ class SharedTableStorage : public TableStorageImpl {
    public:
     explicit iterator(const std::map<string, TableDesc>::iterator &it) : it_(it) {}
     virtual ~iterator() {}
-    virtual unique_ptr<self_type> clone() const override { return make_unique<iterator>(it_); }
+    virtual unique_ptr<self_type> clone() const override { return ebpf::make_unique<iterator>(it_); }
     virtual self_type &operator++() override {
       ++it_;
       return *this;
@@ -62,7 +62,7 @@ bool SharedTableStorage::Find(const string &name, TableStorage::iterator &result
   auto it = tables_.find(name);
   if (it == tables_.end())
     return false;
-  result = TableStorage::iterator(make_unique<iterator>(it));
+  result = TableStorage::iterator(ebpf::make_unique<iterator>(it));
   return true;
 }
 
@@ -83,31 +83,31 @@ bool SharedTableStorage::Delete(const string &name) {
 }
 
 unique_ptr<TableStorageIteratorImpl> SharedTableStorage::begin() {
-  return make_unique<iterator>(tables_.begin());
+  return ebpf::make_unique<iterator>(tables_.begin());
 }
 unique_ptr<TableStorageIteratorImpl> SharedTableStorage::end() {
-  return make_unique<iterator>(tables_.end());
+  return ebpf::make_unique<iterator>(tables_.end());
 }
 
 unique_ptr<TableStorageIteratorImpl> SharedTableStorage::lower_bound(const string &k) {
-  return make_unique<iterator>(tables_.lower_bound(k));
+  return ebpf::make_unique<iterator>(tables_.lower_bound(k));
 }
 unique_ptr<TableStorageIteratorImpl> SharedTableStorage::upper_bound(const string &k) {
-  return make_unique<iterator>(tables_.upper_bound(k));
+  return ebpf::make_unique<iterator>(tables_.upper_bound(k));
 }
 unique_ptr<TableStorageIteratorImpl> SharedTableStorage::erase(const TableStorageIteratorImpl &it) {
   auto i = tables_.find((*it).first);
   if (i == tables_.end())
     return unique_ptr<iterator>();
-  return make_unique<iterator>(tables_.erase(i));
+  return ebpf::make_unique<iterator>(tables_.erase(i));
 }
 
 // All maps for this process are kept in global static storage.
 std::map<string, TableDesc> SharedTableStorage::tables_;
 
 unique_ptr<TableStorage> createSharedTableStorage() {
-  auto t = make_unique<TableStorage>();
-  t->Init(make_unique<SharedTableStorage>());
+  auto t = ebpf::make_unique<TableStorage>();
+  t->Init(ebpf::make_unique<SharedTableStorage>());
   t->AddMapTypesVisitor(createJsonMapTypesVisitor());
   return t;
 }
