linearize_in_tree.patch

diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def
index 436226c6f..5bf05e124 100644
--- a/clang/include/clang/Basic/CodeGenOptions.def
+++ b/clang/include/clang/Basic/CodeGenOptions.def
@@ -504,6 +504,10 @@ CODEGENOPT(OpaquePointers, 1, 0)
 /// non-deleting destructors. (No effect on Microsoft ABI.)
 CODEGENOPT(CtorDtorReturnThis, 1, 0)
 
+
+CODEGENOPT(LinearizeCFG  , 1, 0) ///< Control whether control flow is linearized.
+
+
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT
 #undef VALUE_CODEGENOPT
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 652c15afc..121df8e4d 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -2986,6 +2986,12 @@ def ffinite_loops: Flag<["-"],  "ffinite-loops">, Group<f_Group>,
 def fno_finite_loops: Flag<["-"], "fno-finite-loops">, Group<f_Group>,
   HelpText<"Do not assume that any loop is finite.">, Flags<[CC1Option]>;
 
+// Control Flow Linearization
+def flinearize_cfg : Flag<["-"], "flinearize-cfg">, Group<f_Group>,
+  HelpText<"Turn on control flow linearizeation">, Flags<[CC1Option]>;
+def fno_linearize_cfg : Flag<["-"], "fno-linearize-cfg">, Group<f_Group>,
+  HelpText<"Turn off control flow linearizeation">, Flags<[CC1Option]>;
+
 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
   HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
 def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index 10d6bff25..a14a0d571 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -831,6 +831,7 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
   // Only enable CGProfilePass when using integrated assembler, since
   // non-integrated assemblers don't recognize .cgprofile section.
   PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
+  PTO.LinearizeCFG = CodeGenOpts.LinearizeCFG;
 
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 77554aa2c..226db86f1 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -6335,6 +6335,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
                   options::OPT_fno_unroll_loops);
 
+  Args.AddLastArg(CmdArgs, options::OPT_flinearize_cfg, options::OPT_fno_linearize_cfg);
+
   Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ);
 
   Args.AddLastArg(CmdArgs, options::OPT_pthread);
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
index 0bb9c8c83..bb007cd30 100644
--- a/clang/lib/Frontend/CompilerInvocation.cpp
+++ b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -1420,6 +1420,9 @@ void CompilerInvocation::GenerateCodeGenArgs(
   else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
     GenerateArg(Args, OPT_fno_unroll_loops, SA);
 
+  if (Opts.LinearizeCFG)
+    GenerateArg(Args, OPT_flinearize_cfg, SA);
+
   if (!Opts.BinutilsVersion.empty())
     GenerateArg(Args, OPT_fbinutils_version_EQ, Opts.BinutilsVersion, SA);
 
@@ -1704,6 +1707,9 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
   Opts.UnrollLoops =
       Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
                    (Opts.OptimizationLevel > 1));
+  // Control Flow Linearization
+  Opts.LinearizeCFG =
+      Args.hasFlag(OPT_flinearize_cfg, OPT_fno_linearize_cfg, false);
   Opts.BinutilsVersion =
       std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
 
diff --git a/llvm/include/llvm/CodeGen/CodeGenPassBuilder.h b/llvm/include/llvm/CodeGen/CodeGenPassBuilder.h
index 9ac51ed9f..a52efa1b0 100644
--- a/llvm/include/llvm/CodeGen/CodeGenPassBuilder.h
+++ b/llvm/include/llvm/CodeGen/CodeGenPassBuilder.h
@@ -39,6 +39,7 @@
 #include "llvm/Target/CGPassBuilderOption.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Scalar/ConstantHoisting.h"
+#include "llvm/Transforms/Scalar/Linearize.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
index 1164cd872..472064755 100644
--- a/llvm/include/llvm/InitializePasses.h
+++ b/llvm/include/llvm/InitializePasses.h
@@ -419,6 +419,8 @@ void initializeWinEHPreparePass(PassRegistry&);
 void initializeWriteBitcodePassPass(PassRegistry&);
 void initializeXRayInstrumentationPass(PassRegistry&);
 
+void initializeLinearizePass(PassRegistry&);
+
 } // end namespace llvm
 
 #endif // LLVM_INITIALIZEPASSES_H
diff --git a/llvm/include/llvm/LinkAllPasses.h b/llvm/include/llvm/LinkAllPasses.h
index c76d7adcb..856877305 100644
--- a/llvm/include/llvm/LinkAllPasses.h
+++ b/llvm/include/llvm/LinkAllPasses.h
@@ -215,6 +215,8 @@ namespace {
       (void) llvm::createFixIrreduciblePass();
       (void)llvm::createSelectOptimizePass();
 
+      (void) llvm::createLinearizePass();
+
       (void)new llvm::IntervalPartition();
       (void)new llvm::ScalarEvolutionWrapperPass();
       llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage)->viewCFGOnly();
diff --git a/llvm/include/llvm/Passes/PassBuilder.h b/llvm/include/llvm/Passes/PassBuilder.h
index b7e6764d4..3782c7bf5 100644
--- a/llvm/include/llvm/Passes/PassBuilder.h
+++ b/llvm/include/llvm/Passes/PassBuilder.h
@@ -85,6 +85,9 @@ public:
   // analyses after various module->function or cgscc->function adaptors in the
   // default pipelines.
   bool EagerlyInvalidateAnalyses;
+
+  // CFG linearization
+  bool LinearizeCFG;
 };
 
 /// This class provides access to building LLVM's passes.
diff --git a/llvm/include/llvm/Transforms/Scalar.h b/llvm/include/llvm/Transforms/Scalar.h
index 3db3e41d2..746ec0229 100644
--- a/llvm/include/llvm/Transforms/Scalar.h
+++ b/llvm/include/llvm/Transforms/Scalar.h
@@ -543,6 +543,8 @@ FunctionPass *createInstSimplifyLegacyPass();
 // and scatter intrinsics with scalar code when target doesn't support them.
 //
 FunctionPass *createScalarizeMaskedMemIntrinLegacyPass();
+
+ModulePass *createLinearizePass();
 } // End llvm namespace
 
 #endif
diff --git a/llvm/include/llvm/Transforms/Scalar/Linearize.h b/llvm/include/llvm/Transforms/Scalar/Linearize.h
new file mode 100644
index 000000000..9b83648ba
--- /dev/null
+++ b/llvm/include/llvm/Transforms/Scalar/Linearize.h
@@ -0,0 +1,44 @@
+#ifndef LLVM_TRANSFORMS_SCALAR_LINEARIZE_H
+#define LLVM_TRANSFORMS_SCALAR_LINEARIZE_H
+
+#include <llvm/IR/DerivedTypes.h>
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+
+#include <memory>
+#include <unordered_map>
+
+namespace llvm {
+
+struct LinearizePass : public PassInfoMixin<LinearizePass> {
+	enum labelkind {
+		LBL_FALLTHROUGH,
+		LBL_FRESH,
+	};
+
+	struct label {
+		labelkind kind;
+		size_t fresh;
+	};
+
+	PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+	bool runOnFunction(Function &F);
+
+	std::pair<size_t, Align> getDiscardSizeAlign(Function &F, const DataLayout &DataLayout);
+	size_t getLabels(Function &F);
+	void shuffleBlocks(Function &F, size_t numlbl);
+	void eliminatePhis(Function &F);
+	void handleIntrinsics(BasicBlock &BB);
+	void resolveContinuityErrors(Function &F);
+	Value *prepareBlock(BasicBlock &bb, Value *on, AllocaInst *selector, label label, AllocaInst *discard);
+	
+	template <typename T>
+	void linearizeIns(T *ins, Value *on, AllocaInst *discard);
+
+	std::unordered_map<BasicBlock *, struct label> labels;
+	std::unique_ptr<RandomNumberGenerator> rng;
+	Function *NopFun;
+};
+}
+
+#endif // LLVM_TRANSFORMS_SCALAR_LINEARIZE_H
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index e251d5646..c61bb9ed3 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -171,6 +171,7 @@
 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
 #include "llvm/Transforms/Scalar/JumpThreading.h"
 #include "llvm/Transforms/Scalar/LICM.h"
+#include "llvm/Transforms/Scalar/Linearize.h"
 #include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h"
 #include "llvm/Transforms/Scalar/LoopBoundSplit.h"
 #include "llvm/Transforms/Scalar/LoopDataPrefetch.h"
diff --git a/llvm/lib/Passes/PassBuilderPipelines.cpp b/llvm/lib/Passes/PassBuilderPipelines.cpp
index 0d074951c..d4fd7595a 100644
--- a/llvm/lib/Passes/PassBuilderPipelines.cpp
+++ b/llvm/lib/Passes/PassBuilderPipelines.cpp
@@ -88,6 +88,7 @@
 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
 #include "llvm/Transforms/Scalar/JumpThreading.h"
 #include "llvm/Transforms/Scalar/LICM.h"
+#include "llvm/Transforms/Scalar/Linearize.h"
 #include "llvm/Transforms/Scalar/LoopDeletion.h"
 #include "llvm/Transforms/Scalar/LoopDistribute.h"
 #include "llvm/Transforms/Scalar/LoopFlatten.h"
@@ -291,6 +292,7 @@ PipelineTuningOptions::PipelineTuningOptions() {
   MergeFunctions = EnableMergeFunctions;
   InlinerThreshold = -1;
   EagerlyInvalidateAnalyses = EnableEagerlyInvalidateAnalyses;
+  LinearizeCFG = false;
 }
 
 namespace llvm {
@@ -1354,9 +1356,14 @@ PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(OptimizePM),
                                                 PTO.EagerlyInvalidateAnalyses));
 
+
   for (auto &C : OptimizerLastEPCallbacks)
     C(MPM, Level);
 
+  // add cfg linearization pass
+  if (PTO.LinearizeCFG)
+    MPM.addPass(LinearizePass());
+
   // Split out cold code. Splitting is done late to avoid hiding context from
   // other optimizations and inadvertently regressing performance. The tradeoff
   // is that this has a higher code size cost than splitting early.
@@ -1959,6 +1966,10 @@ ModulePassManager PassBuilder::buildO0DefaultPipeline(OptimizationLevel Level,
   for (auto &C : OptimizerLastEPCallbacks)
     C(MPM, Level);
 
+  // add cfg linearization pass
+  if (PTO.LinearizeCFG)
+    MPM.addPass(LinearizePass());
+
   if (LTOPreLink)
     addRequiredLTOPreLinkPasses(MPM);
 
diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def
index 10af4160c..e62bcd192 100644
--- a/llvm/lib/Passes/PassRegistry.def
+++ b/llvm/lib/Passes/PassRegistry.def
@@ -127,6 +127,7 @@ MODULE_PASS("sanmd-module", SanitizerBinaryMetadataPass())
 MODULE_PASS("memprof-module", ModuleMemProfilerPass())
 MODULE_PASS("poison-checking", PoisonCheckingPass())
 MODULE_PASS("pseudo-probe-update", PseudoProbeUpdatePass())
+MODULE_PASS("linearize", LinearizePass())
 #undef MODULE_PASS
 
 #ifndef MODULE_PASS_WITH_PARAMS
diff --git a/llvm/lib/Transforms/Scalar/CMakeLists.txt b/llvm/lib/Transforms/Scalar/CMakeLists.txt
index eb008c159..750dd6d9a 100644
--- a/llvm/lib/Transforms/Scalar/CMakeLists.txt
+++ b/llvm/lib/Transforms/Scalar/CMakeLists.txt
@@ -79,6 +79,8 @@ add_llvm_component_library(LLVMScalarOpts
   TLSVariableHoist.cpp
   WarnMissedTransforms.cpp
 
+  Linearize.cpp
+
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms/Scalar
diff --git a/llvm/lib/Transforms/Scalar/Linearize.cpp b/llvm/lib/Transforms/Scalar/Linearize.cpp
new file mode 100644
index 000000000..d3712f31c
--- /dev/null
+++ b/llvm/lib/Transforms/Scalar/Linearize.cpp
@@ -0,0 +1,842 @@
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/Passes/PassPlugin.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/PostDominators.h"
+
+#include "llvm/InitializePasses.h"
+
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+
+#include "llvm/Transforms/Scalar/Linearize.h"
+
+#include <algorithm>
+#include <utility>
+#include <list>
+#include <vector>
+
+using namespace llvm;
+
+bool removeIntrin(CallInst *ci) {
+	ci->eraseFromParent();
+	return true;
+}
+
+bool translateMemset(CallInst *ci) {
+	LLVMContext &ctx = ci->getContext();
+	Module *M = ci->getParent()->getParent()->getParent();
+	auto &dl = M->getDataLayout();
+	IntegerType *sizet = IntegerType::getIntNTy(ctx, dl.getMaxIndexSizeInBits());
+	IRBuilder<> Builder(ci);
+
+	FunctionType *ft = FunctionType::get(Type::getVoidTy(ctx), {Type::getInt8PtrTy(ctx), Type::getInt32Ty(ctx), sizet}, false);
+	FunctionCallee fc = M->getOrInsertFunction("memset", ft);
+
+	Builder.CreateCall(fc,
+		{ ci->getOperand(0)
+		, Builder.CreateZExt(ci->getOperand(1)
+		, Builder.getInt32Ty()), Builder.CreateZExtOrTrunc(ci->getOperand(2), sizet)});
+
+	ci->eraseFromParent();
+	return true;
+}
+
+bool translateMemcpy(CallInst *ci) {
+	LLVMContext &ctx = ci->getContext();
+	Module *M = ci->getParent()->getParent()->getParent();
+	auto &dl = M->getDataLayout();
+	IntegerType *sizet = IntegerType::getIntNTy(ctx, dl.getMaxIndexSizeInBits());
+	IRBuilder<> Builder(ci);
+
+	FunctionType *ft = FunctionType::get(Type::getVoidTy(ctx), {Type::getInt8PtrTy(ctx), Type::getInt8PtrTy(ctx) , sizet}, false);
+	FunctionCallee fc = M->getOrInsertFunction("memcpy", ft);
+
+	Builder.CreateCall(fc,
+		{ ci->getOperand(0)
+		, ci->getOperand(1)
+		, Builder.CreateZExtOrTrunc(ci->getOperand(2), sizet)});
+
+	ci->eraseFromParent();
+	return true;
+}
+
+static std::unordered_map<Intrinsic::ID, std::function<bool(CallInst*)> > intrinMap =
+	{ {Intrinsic::lifetime_start, removeIntrin}
+	, {Intrinsic::lifetime_end,   removeIntrin}
+	, {Intrinsic::memset,		  translateMemset}
+	, {Intrinsic::memcpy,		  translateMemcpy}};
+
+void LinearizePass::handleIntrinsics(BasicBlock &BB) {
+	SmallVector<CallInst *, 64> intrins;
+
+	for (Instruction &Ins : BB) {
+		CallInst *ci = dyn_cast<CallInst>(&Ins);
+		if (!ci || ci->getIntrinsicID() == Intrinsic::not_intrinsic)
+			continue;
+		intrins.push_back(ci);
+	}
+
+	for (CallInst *ci : intrins) {
+		Intrinsic::ID id = ci->getIntrinsicID();
+		AttributeList al = Intrinsic::getAttributes(BB.getContext(), id);
+		if (!Intrinsic::isOverloaded(id))
+			dbgs() << "Intrinsic " << Intrinsic::getName(id) << " has Attribtues:\n";
+		else
+			dbgs() << "Intrinsic " << Intrinsic::getBaseName(id) << " has Attribtues:\n";
+		al.print(dbgs());
+
+		if (ci->doesNotAccessMemory() && al.hasFnAttr(Attribute::WillReturn)) {
+			dbgs() << "Ignoring due to readnone\n";
+			continue;
+		}
+
+		auto it = intrinMap.find(id);
+		if (it != intrinMap.end()) {
+			assert(it->second(ci));
+			continue;
+		}
+
+		errs() << "no replacement function found for\n";
+		ci->print(errs());
+		errs() << "\n";
+		llvm_unreachable("no intrinsic translation");
+	}
+}
+
+void LinearizePass::resolveContinuityErrors(Function &F) {
+	SmallVector<Instruction *> tofix;
+	for (auto it = ++F.begin(); it != F.end(); ++it) {
+		BasicBlock *home = &*it;
+		for (Instruction &ins : *it) {
+			for (Use &u : ins.uses()) {
+				Instruction *iu = cast<Instruction>(u.getUser());
+				assert(!isa<PHINode>(iu) && "phi has not been eliminated");
+				if (iu->getParent() == home)
+					continue;
+				tofix.push_back(&ins);
+				break;
+			}
+		}
+	}
+
+	Instruction *first_ins = F.begin()->getFirstNonPHIOrDbg();
+	SmallVector<Use *> uses;
+	std::unordered_map<BasicBlock *, LoadInst *> bbLoadMap;
+	bbLoadMap.reserve(100);
+	for (Instruction *ins : tofix) {
+		dbgs() << "fixing ";
+		ins->print(dbgs());
+		dbgs() << "\n";
+		Type *ty = ins->getType();
+		BasicBlock *home = ins->getParent();
+		AllocaInst *alloc = new AllocaInst(ty, 0, Twine(ins->getName(), ".ins.rewrite"), first_ins);
+
+		new StoreInst(ins, alloc, ins->getNextNonDebugInstruction());
+
+		uses.clear();
+		bbLoadMap.clear();
+		for (Use &u : ins->uses()) {
+			Instruction *iu = cast<Instruction>(u.getUser());
+			assert(!isa<PHINode>(iu));
+
+			if (iu->getParent() != home)
+				uses.push_back(&u);
+		}
+
+		for (Use *u : uses) {
+			Instruction *uins = cast<Instruction>(u->getUser());
+			dbgs() << "rewriting use ";
+			uins->print(dbgs());
+			LoadInst *load = nullptr;
+			BasicBlock *bb = uins->getParent();
+			auto it = bbLoadMap.find(bb);
+			if (it != bbLoadMap.end()) {
+				load = it->second;
+				dbgs() << "in " << bb->getName() << " (shared)\n";
+			} else {
+				load = new LoadInst(ty, alloc, Twine(ins->getName(), ".ins.use"), cast<Instruction>(bb->getFirstNonPHIOrDbg()));
+				bbLoadMap.emplace(bb, load);
+				dbgs() << "in " << bb->getName() << " (fresh)\n";
+			}
+			assert(load != nullptr);
+			u->set(load);
+		}
+	}
+}
+
+/**
+ * Rewrites phi nodes as memory allocation + access
+ * needs to be run before memory access are rewritten
+ */
+void LinearizePass::eliminatePhis(Function &F) {
+	std::vector<PHINode *> phis;
+	for (BasicBlock &bb : F) {
+		for (Instruction &ins : bb) {
+			PHINode *phi = dyn_cast<PHINode>(&ins);
+			if (phi)
+				phis.push_back(phi);
+		}
+	}
+
+	Instruction *first_ins = F.begin()->getFirstNonPHI();
+
+	SmallVector<Use *> uses;
+	std::unordered_map<BasicBlock *, LoadInst *> bbLoadMap;
+	bbLoadMap.reserve(100);
+	for (PHINode *phi : phis) {
+		Type *ty = phi->getType();
+		dbgs() << "rewriting ";
+		phi->print(dbgs());
+		dbgs() << "\n";
+		AllocaInst *alloc = new AllocaInst(ty, 0, Twine(phi->getName(), ".phi.rewrite"), first_ins);
+		for (unsigned i = 0; i < phi->getNumIncomingValues(); ++i) {
+			// skip duplicate edges
+			BasicBlock *bb = phi->getIncomingBlock(i);
+			if (phi->getBasicBlockIndex(bb) != i) continue;
+			Value *v = phi->getIncomingValue(i);
+
+			// self references can not be ignored in general see:
+			//
+			// A -> B; (phi a)
+			// B -> A; (phi a = a + 1)
+			// B -> C;
+			// C -> A; (phi a = a) - self reference
+			//
+			// a.phi.rewrite will always be overwritten in B
+			// and would need to be reset to the original value in C
+			//
+			// mutliple writes to a.phi.rewrite are fine only if
+			// the last write is corresponding to the incoming edge of the phi
+			// if (dyn_cast<PHINode>(v) == phi) continue;
+
+			// store will be rewritten using on later on
+			new StoreInst(v, alloc, bb->getTerminator());
+		}
+
+		LoadInst *phi_replace = new LoadInst(ty, alloc, phi->getName(), phi);
+		phi->replaceAllUsesWith(phi_replace);
+		phi->eraseFromParent();
+	}
+}
+
+void LinearizePass::shuffleBlocks(Function &F, size_t numlbl) {
+	std::vector<BasicBlock*> bbs;
+	std::vector<std::pair<BasicBlock *, BasicBlock*> > fallthroughs;
+	bbs.reserve(numlbl);
+	fallthroughs.reserve(F.size() - numlbl);
+	BasicBlock *last = nullptr;
+
+	dbgs() << "shuffling\n";
+
+	for (auto it = ++F.begin(); it != F.end(); ++it) {
+		if (labels.at(&*it).kind == LBL_FRESH) {
+			bbs.emplace(bbs.begin() + ((*rng)() % (bbs.size() + 1)), &*it);
+		} else {
+			fallthroughs.emplace_back(&*it, last);
+		}
+		last = &*it;
+	}
+
+	dbgs() << "shuffled\n";
+
+	BasicBlock *ip = &*--F.end();
+	for (BasicBlock *bb : bbs) {
+		bb->moveBefore(ip);
+	}
+	for (std::pair<BasicBlock *, BasicBlock *> &ft : fallthroughs) {
+		ft.first->moveAfter(ft.second);
+	}
+}
+
+size_t LinearizePass::getLabels(Function &F) {
+	labels.reserve(F.size());
+
+	BasicBlock *last = nullptr;
+
+	size_t numlbl = 0;
+
+	auto it = std::next(F.begin());
+
+	bool first = true;
+	for (; it != F.end(); ++it) {
+		BasicBlock *bb = &*it;
+		if (first) {
+			dbgs() << bb->getName() << ": fresh\n";
+			labels[bb] = label{LBL_FRESH, (*rng)()};
+			last = bb;
+			first = false;
+			++numlbl;
+			continue;
+		}
+
+		if (last == bb->getUniquePredecessor()) {
+			dbgs() << bb->getName() << ": fallthrough\n";
+			labels[bb] = label{LBL_FALLTHROUGH};
+			last = bb;
+			continue;
+		}
+
+		dbgs() << bb->getName() << ": fresh\n";
+		labels[bb] = label{LBL_FRESH, (*rng)()};
+		last = bb;
+		++numlbl;
+	}
+
+	return numlbl;
+}
+
+template <>
+void LinearizePass::linearizeIns<LoadInst>(LoadInst *ins, Value *on, AllocaInst *discard) {
+	Value *ptr = ins->getPointerOperand();
+	if (isa<Constant>(ptr) || isa<AllocaInst>(ptr))
+		return;
+	IRBuilder<> Builder(ins);
+	*ins->op_begin() = Builder.CreateSelect(
+		on,
+		ins->getPointerOperand(),
+		Builder.CreatePointerCast(discard, ins->getPointerOperandType()));
+}
+
+template <>
+void LinearizePass::linearizeIns<StoreInst>(StoreInst *ins, Value *on, AllocaInst *discard) {
+	IRBuilder<> Builder(ins);
+	*std::next(ins->op_begin()) = Builder.CreateSelect(
+		on,
+		ins->getPointerOperand(),
+		Builder.CreatePointerCast(discard, ins->getPointerOperandType()));
+}
+
+template <>
+void LinearizePass::linearizeIns<AtomicCmpXchgInst>(AtomicCmpXchgInst *ins, Value *on, AllocaInst *discard) {
+	IRBuilder<> Builder(ins);
+	*ins->op_begin() = Builder.CreateSelect(
+		on,
+		ins->getPointerOperand(),
+		Builder.CreatePointerCast(discard, ins->getPointerOperand()->getType()));
+}
+
+template <>
+void LinearizePass::linearizeIns<AtomicRMWInst>(AtomicRMWInst *ins, Value *on, AllocaInst *discard) {
+	IRBuilder<> Builder(ins);
+	*ins->op_begin() = Builder.CreateSelect(
+		on,
+		ins->getPointerOperand(),
+		Builder.CreatePointerCast(discard, ins->getPointerOperand()->getType()));
+}
+
+template <>
+void LinearizePass::linearizeIns<CallInst>(CallInst *ins, Value *on, AllocaInst *discard) {
+	IRBuilder<> Builder(ins);
+	ins->setCalledOperand(
+		Builder.CreateSelect(on,
+			ins->getCalledOperand(),
+			Builder.CreatePointerCast(NopFun, ins->getCalledOperand()->getType())));
+}
+
+template <>
+void LinearizePass::linearizeIns<GetElementPtrInst>(GetElementPtrInst *ins, Value *on, AllocaInst *discard) {
+	ins->setIsInBounds(false);
+}
+
+template <>
+void LinearizePass::linearizeIns<BinaryOperator>(BinaryOperator *op, Value *on, AllocaInst *discard) {
+	IRBuilder<> Builder(op);
+	Type *typ = op->getType();
+	switch(op->getOpcode()) {
+	case Instruction::SDiv:
+	case Instruction::UDiv:
+	case Instruction::SRem:
+	case Instruction::URem:
+		if (isa<Constant>(op->getOperand(1))) return;
+		op->setOperand(1,
+			Builder.CreateOr(op->getOperand(1),
+				Builder.CreateZExtOrTrunc(
+					Builder.CreateXor(on, ConstantInt::getTrue(on->getType()))
+					, typ)));
+		break;
+	case Instruction::Shl:
+	case Instruction::AShr:
+	case Instruction::LShr:
+		if (isa<Constant>(op->getOperand(1))) return;
+		op->setOperand(1,
+			Builder.CreateAnd(op->getOperand(1), ConstantInt::get(typ, typ->getIntegerBitWidth() - 1)));
+		break;
+	default:
+		break;
+	}
+}
+
+Value *LinearizePass::prepareBlock(BasicBlock &bb, Value *on, AllocaInst *selector, label label, AllocaInst *discard) {
+	std::vector<Instruction *> todo;
+
+	for (Instruction &ins : bb) {
+		// TODO elaborate intrinsic handling
+		CallInst *ci = dyn_cast<CallInst>(&ins);
+		if (ci && ci->getIntrinsicID() == Intrinsic::not_intrinsic) {
+			dbgs() << "removing addtributes from:";
+			ci->print(dbgs());
+			dbgs() << "\n";
+			ci->setAttributes(AttributeList::get(ci->getContext(), ArrayRef<AttributeList>()));
+		}
+
+		if (isa<LoadInst>(&ins) ||
+			isa<StoreInst>(&ins) ||
+			isa<AtomicCmpXchgInst>(&ins) ||
+			isa<AtomicRMWInst>(&ins) ||
+			isa<GetElementPtrInst>(&ins) ||
+			(ci && ci->getIntrinsicID() == Intrinsic::not_intrinsic) ||
+			ins.getOpcode() == Instruction::SDiv ||
+			ins.getOpcode() == Instruction::UDiv ||
+			ins.getOpcode() == Instruction::URem ||
+			ins.getOpcode() == Instruction::SRem ||
+			ins.getOpcode() == Instruction::Shl ||
+			ins.getOpcode() == Instruction::AShr ||
+			ins.getOpcode() == Instruction::LShr) {
+			todo.push_back(&ins);
+		}
+	}
+
+	if (label.kind == LBL_FRESH) {
+		IRBuilder<> Builder(bb.getFirstNonPHIOrDbgOrLifetime());
+		on = Builder.CreateICmpEQ(
+			Builder.CreateLoad(selector->getAllocatedType(), selector),
+			Builder.getInt64(label.fresh), Twine(bb.getName(), ".on"));
+	}
+
+	for (Instruction *ins : todo) {
+		LoadInst *li = dyn_cast<LoadInst>(ins);
+		if (li) {
+			linearizeIns(li, on, discard);
+			continue;
+		}
+
+		StoreInst *si = dyn_cast<StoreInst>(ins);
+		if (si) {
+			linearizeIns(si, on, discard);
+			continue;
+		}
+
+		AtomicCmpXchgInst *xchg = dyn_cast<AtomicCmpXchgInst>(ins);
+		if (xchg) {
+			linearizeIns(xchg, on, discard);
+			continue;
+		}
+
+		AtomicRMWInst *rmw = dyn_cast<AtomicRMWInst>(ins);
+		if (rmw) {
+			linearizeIns(rmw, on, discard);
+			continue;
+		}
+
+		CallInst *call = dyn_cast<CallInst>(ins);
+		if (call) {
+			linearizeIns(call, on, discard);
+			continue;
+		}
+
+		BinaryOperator *bop = dyn_cast<BinaryOperator>(ins);
+		if (bop) {
+			linearizeIns(bop, on, discard);
+			continue;
+		}
+
+		GetElementPtrInst *gep = dyn_cast<GetElementPtrInst>(ins);
+		if (gep) {
+			linearizeIns(gep, on ,discard);
+			continue;
+		}
+	}
+
+	return on;
+}
+
+std::pair<size_t, Align> LinearizePass::getDiscardSizeAlign(Function &F, const DataLayout &DataLayout) {
+	size_t size = DataLayout.getPointerSize();
+	Align align = DataLayout.getPointerPrefAlignment();
+	for (BasicBlock &bb : F) {
+		for (Instruction &ins : bb) {
+			StoreInst *si = dyn_cast<StoreInst>(&ins);
+			if (si) {
+				si->print(dbgs());
+				dbgs() << "\n";
+				Type *t = si->getValueOperand()->getType();
+				size_t tmp = DataLayout.getTypeAllocSize(t);
+				Align tmpalign = DataLayout.getValueOrABITypeAlignment(si->getAlign(), t);
+				if (tmp > size)
+					size = tmp;
+				if (tmpalign > align)
+					align = tmpalign;
+				continue;
+			}
+
+			LoadInst *li = dyn_cast<LoadInst>(&ins);
+			if (li) {
+				li->print(dbgs());
+				dbgs() << "\n";
+				size_t tmp = DataLayout.getTypeAllocSize(li->getType());
+				Align tmpalign = DataLayout.getValueOrABITypeAlignment(li->getAlign(), li->getType());
+				if (tmp > size)
+					size = tmp;
+				if (tmpalign > align)
+					align = tmpalign;
+				continue;
+			}
+
+			AtomicCmpXchgInst *cmpXchg = dyn_cast<AtomicCmpXchgInst>(&ins);
+			if (cmpXchg) {
+				cmpXchg->print(dbgs());
+				dbgs() << "\n";
+				Type *t = cmpXchg->getNewValOperand()->getType();
+				size_t tmp = DataLayout.getTypeAllocSize(t);
+				Align tmpalign = DataLayout.getValueOrABITypeAlignment(cmpXchg->getAlign(), t);
+				if (tmp > size)
+					size = tmp;
+				if (tmpalign > align)
+					align = tmpalign;
+				continue;
+			}
+
+			AtomicRMWInst *rmw = dyn_cast<AtomicRMWInst>(&ins);
+			if (rmw) {
+				rmw->print(dbgs());
+				dbgs() << "\n";
+				size_t tmp = DataLayout.getTypeAllocSize(rmw->getType());
+				Align tmpalign = DataLayout.getValueOrABITypeAlignment(rmw->getAlign(), rmw->getType());
+				if (tmp > size)
+					size = tmp;
+				if (tmpalign > align)
+					align = tmpalign;
+			}
+		}
+	}
+
+	return {size, align};
+}
+
+bool LinearizePass::runOnFunction(Function &F) {
+	dbgs() << "linearizing " << F.getName() << "\n";
+	labels.clear();
+
+	auto it = F.getEntryBlock().begin();
+	while(isa<AllocaInst>(it) ||
+		(isa<CallInst>(it) && cast<CallInst>(it)->getIntrinsicID() != Intrinsic::not_intrinsic) ||
+		isa<StoreInst>(it)) {
+		++it;
+	}
+
+	// check state of function
+	// check terminators
+	for (BasicBlock &bb : F) {
+		Instruction *ins = bb.getTerminator();
+		if (!isa<BranchInst>(ins) &&
+			!isa<ReturnInst>(ins)) {
+			dbgs() << "incompatible terminator: ";
+			ins->print(dbgs());
+			return false;
+		}
+
+	}
+
+	// search for allocas within the function body
+	for (auto it2 = it; it2 != F.getEntryBlock().end(); ++it2) {
+		if (isa<AllocaInst>(&*it2)) {
+			dbgs() << "found alloca within function body, aborting\n";
+			return false;
+		}
+	}
+
+	for (auto it = ++F.begin(); it != F.end(); ++it) {
+		for (Instruction &ins : *it) {
+			if (isa<AllocaInst>(&ins)) {
+				dbgs() << "found alloca within function body, aborting\n";
+				return false;
+			}
+		}
+	}
+
+	for (BasicBlock &BB : F)
+		handleIntrinsics(BB);
+
+	// TODO: eliminate phis
+	eliminatePhis(F);
+
+	// create auxiliary local variables
+	std::pair<size_t, Align> discardSizeAlign = getDiscardSizeAlign(F, F.getParent()->getDataLayout());
+
+	Instruction *split = &*it;
+	AllocaInst *discard;
+	AllocaInst *selector;
+	AllocaInst *retval;
+	{
+		IRBuilder<> Builder(F.begin()->getFirstNonPHI());
+		discard = Builder.CreateAlloca(ArrayType::get(Builder.getInt8Ty(), discardSizeAlign.first), nullptr, "discard");
+		discard->setAlignment(discardSizeAlign.second);
+		selector = Builder.CreateAlloca(Builder.getInt64Ty(), nullptr, "selector");
+		if (!F.getReturnType()->isVoidTy())
+			retval = Builder.CreateAlloca(F.getReturnType(), nullptr, "retval");
+	}
+
+	SplitBlock(&F.getEntryBlock(), split);
+
+//	F.print(dbgs());
+//	dbgs() << "\n";
+
+	size_t numlbl = getLabels(F);
+
+	// TODO: shuffle blocks
+	shuffleBlocks(F, numlbl);
+
+	resolveContinuityErrors(F);
+
+//	F.print(dbgs());
+//	dbgs() << "\n";
+
+	size_t finlbl = (*rng)();
+	Value *on = nullptr;
+	for (auto bbit = ++F.begin(); bbit != F.end(); ++bbit) {
+		on = prepareBlock(*bbit, on, selector, labels[&*bbit], discard);
+		dbgs() << "fixing continuation in " << bbit->getName() << "\n";
+		BranchInst *br = dyn_cast<BranchInst>(bbit->getTerminator());
+		IRBuilder<> Builder(bbit->getTerminator());
+		if (br) {
+			label tl = labels[br->getSuccessor(0)];
+			if (br->isConditional()) {
+				label fl = labels[br->getSuccessor(1)];
+				if (tl.kind != LBL_FALLTHROUGH && fl.kind != LBL_FALLTHROUGH) {
+					Builder.CreateStore(
+						Builder.CreateSelect(
+							br->getCondition(),
+							Builder.getInt64(tl.fresh),
+							Builder.getInt64(fl.fresh)),
+						Builder.CreateSelect(
+							on,
+							selector,
+							Builder.CreatePointerCast(discard, Builder.getInt64Ty()->getPointerTo())));
+					continue;
+				}
+				Value *ptr;
+				size_t val;
+				if (tl.kind == LBL_FRESH) {
+					ptr = Builder.CreateSelect(Builder.CreateAnd(br->getCondition(), on)
+						, selector
+						, Builder.CreatePointerCast(discard, Builder.getInt64Ty()->getPointerTo()));
+					val = tl.fresh;
+					on = Builder.CreateAnd(on, Builder.CreateNot(br->getCondition()), Twine(br->getSuccessor(1)->getName(), ".on"));
+				} else {
+					assert(fl.kind == LBL_FRESH);
+					ptr = Builder.CreateSelect(Builder.CreateOr(br->getCondition(), Builder.CreateNot(on))
+						, Builder.CreatePointerCast(discard, Builder.getInt64Ty()->getPointerTo())
+						, selector);
+					val = fl.fresh;
+					on = Builder.CreateAnd(on, br->getCondition(), Twine(br->getSuccessor(0)->getName(), ".on"));
+				}
+
+				Builder.CreateStore(Builder.getInt64(val), ptr);
+				continue;
+			}
+
+			if (tl.kind == LBL_FRESH && on == nullptr) {
+				Builder.CreateStore(Builder.getInt64(tl.fresh), selector);
+				continue;
+			}
+
+			if (tl.kind == LBL_FRESH) {
+				Builder.CreateStore(Builder.getInt64(tl.fresh),
+					Builder.CreateSelect(
+						on,
+						selector,
+						Builder.CreatePointerCast(discard, Builder.getInt64Ty()->getPointerTo())));
+				continue;
+			}
+
+			assert(tl.kind == LBL_FALLTHROUGH);
+			continue;
+		}
+
+		dbgs() << "rewriting return instruction\n";
+		ReturnInst *ret = cast<ReturnInst>(bbit->getTerminator());
+		Value *rv = ret->getReturnValue();
+		if (rv) {
+			Builder.CreateStore(rv,
+				Builder.CreateSelect(on, retval, Builder.CreatePointerCast(discard, rv->getType()->getPointerTo())));
+		}
+		Builder.CreateStore(Builder.getInt64(finlbl),
+			Builder.CreateSelect(on, selector, Builder.CreatePointerCast(discard, Builder.getInt64Ty()->getPointerTo())));
+	}
+
+	// create common exit block
+	BasicBlock *commonFin = BasicBlock::Create(F.getParent()->getContext(), "fin", &F);
+	{
+		IRBuilder<> Builder(commonFin);
+		if (F.getReturnType()->isVoidTy()) {
+			Builder.CreateRetVoid();
+		} else {
+			Builder.CreateRet(
+				Builder.CreateLoad(F.getReturnType(), retval, "retval"));
+		}
+	}
+
+	// merge fallthroughs
+	{
+		BasicBlock *last = &*++F.begin();
+		SmallVector<BasicBlock *, 64> todel;
+
+		for (auto it = ++++F.begin(); it != --F.end(); ++it) {
+			if (labels[&*it].kind == LBL_FRESH) {
+				last = &*it;
+				continue;
+			}
+
+			dbgs() << "merging fallthrough " << it->getName() << " into " << last->getName() << "\n";
+
+			// merge bb
+			last->getTerminator()->eraseFromParent();
+			last->splice(last->end(), &*it);
+			todel.push_back(&*it);
+		}
+
+		for (BasicBlock *bb : todel)
+			bb->eraseFromParent();
+	}
+
+	// merge bbs
+	{
+		std::vector<BasicBlock*> bbs;
+		bbs.reserve(F.size() - 2);
+
+		// accumulate instruction in it
+		BasicBlock *tar = BasicBlock::Create(F.getParent()->getContext(), "merged", &F, &*std::next(F.begin()));
+
+		// rewire branch from entry block
+		new StoreInst(
+			ConstantInt::get(IntegerType::get(F.getParent()->getContext(), 64), labels[F.begin()->getSingleSuccessor()].fresh, false)
+			, selector
+			, F.begin()->getTerminator());
+		cast<BranchInst>(F.begin()->getTerminator())->setSuccessor(0, tar);
+
+		std::list<BasicBlock *> bblist;
+		size_t num_inst = 0;
+		for (auto it = std::next(std::next(F.begin())); std::next(it) != F.end(); ++it) {
+			it->getTerminator()->eraseFromParent();
+			num_inst += it->size();
+			bblist.push_back(&*it);
+		}
+
+		/*
+		// just paste the basicblocks one after the other without interleaving 
+		for (BasicBlock *bb : bblist) {
+			tar->splice(tar->end(), &*bb);
+			bb->eraseFromParent();
+		}
+		*/
+
+		// this loop interleaves the instructions from all basic blocks to make it more difficult
+		// to separate basic blocks. Unfortunately this reintroduces jumps (on x86) as the register
+		// preassure is significantly higher. If you don't need or want this hardening you can simply
+		// merge all basic blocks with the code above
+		while (num_inst) {
+//			dbgs() << "instructions left: " << num_inst << "\n";
+			auto it = bblist.begin();
+			size_t pos = (*rng)() % num_inst;
+			while (pos > (*it)->size()) {
+//				dbgs() << "instructions left (" << (*it)->getName() << "): " << (*it)->size() << "\n";
+				pos -= (*it)->size();
+				++it;
+			}
+
+			/*
+			for (size_t pos = (*rng)() % num_inst; pos > (*it)->size(); pos -= (*it)->size()) {
+				++it;
+			}*/
+
+			size_t left = (*it)->size();
+			size_t num = std::min(left, 3 + (*rng)() % 3);
+//			dbgs() << "taking " << num << " instructions from " << (*it)->getName() << "\n";
+			auto ei = (*it)->begin();
+			for (size_t i = 0; i < num; ++i) {
+				assert(ei != (*it)->end());
+				ei = std::next(ei);
+			}
+			//std::advance(ei, num);
+			tar->splice(tar->end(), *it, (*it)->begin(), ei);
+			num_inst -= num;
+			if (num == left) {
+//				dbgs() << "block " << (*it)->size() << " is depelted - erasing\n";
+				BasicBlock *todel = *it;
+				bblist.erase(it);
+				todel->eraseFromParent();
+			}
+		}
+
+		IRBuilder<> Builder(tar);
+		Builder.CreateCondBr(
+			Builder.CreateICmpEQ(
+				Builder.getInt64(finlbl),
+				Builder.CreateLoad(Builder.getInt64Ty(), selector, "tag"),
+				"isExit"),
+			commonFin,
+			tar);
+	}
+
+	F.print(dbgs());
+	dbgs() << "\n";
+
+	return true;
+}
+
+PreservedAnalyses LinearizePass::run(Module &M, ModuleAnalysisManager &MAM) {
+	SmallString<64> rngstr = {"obf.linearize"};
+	rng = M.createRNG(rngstr);
+
+	NopFun = Function::Create(FunctionType::get(IntegerType::get(M.getContext(), 8)->getPointerTo(), {}, true), GlobalValue::LinkOnceODRLinkage, "__obf_nop", M);
+	NopFun->setVisibility(GlobalValue::HiddenVisibility);
+
+	for (Function &F : M) {
+		if (F.isDeclaration() || F.hasOptNone() || F.isVarArg())
+			continue;
+
+		runOnFunction(F);
+	}
+
+	{
+		BasicBlock *bb = BasicBlock::Create(M.getContext(), "entry", NopFun);
+		ReturnInst::Create(M.getContext(), Constant::getNullValue(NopFun->getReturnType()), bb);
+	}
+
+	return PreservedAnalyses::none();
+}
+
+namespace {
+	struct Linearize : public ModulePass {
+		static char ID;
+		Linearize() : ModulePass(ID) {
+			initializeLinearizePass(*PassRegistry::getPassRegistry());
+		}
+
+		bool runOnModule(Module &M) override;
+	};
+}
+
+char Linearize::ID = 0;
+INITIALIZE_PASS(Linearize, "linearize", "control flow linearization", false, false)
+
+ModulePass *llvm::createLinearizePass() {return new Linearize(); }
+
+bool Linearize::runOnModule(Module &M) {
+	return false;
+}
+
+/*
+extern "C" LLVM_ATTRIBUTE_WEAK PassPluginLibraryInfo llvmGetPassPluginInfo() {
+	return {LLVM_PLUGIN_API_VERSION, "linearize", "0.1", [](PassBuilder &PB) {
+		PB.registerOptimizerLastEPCallback([](ModulePassManager &MPM, OptimizationLevel Ol) {
+			MPM.addPass(Linearize());
+		});
+	}};
+}
+*/
\ No newline at end of file
diff --git a/llvm/lib/Transforms/Scalar/Scalar.cpp b/llvm/lib/Transforms/Scalar/Scalar.cpp
index 8aee8d140..e3910f70a 100644
--- a/llvm/lib/Transforms/Scalar/Scalar.cpp
+++ b/llvm/lib/Transforms/Scalar/Scalar.cpp
@@ -109,6 +109,8 @@ void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeLoopLoadEliminationPass(Registry);
   initializeLoopSimplifyCFGLegacyPassPass(Registry);
   initializeLoopVersioningLegacyPassPass(Registry);
+
+  initializeLinearizePass(Registry);
 }
 
 void LLVMAddLoopSimplifyCFGPass(LLVMPassManagerRef PM) {