Resolve llvm#101. Add an early pass called KillUB the removes all UB-enabling flags from LLVM IR. 0.8% regression on PizBench9017, which I think is worth it. I bet the regression is from disabling strict aliasing.

Author: pizlonator

clang/lib/CodeGen/BackendUtil.cpp

@@ -72,6 +72,7 @@
 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
 #include "llvm/Transforms/Instrumentation/KCFI.h"
+#include "llvm/Transforms/Instrumentation/KillUB.h"
 #include "llvm/Transforms/Instrumentation/LowerAllowCheckPass.h"
 #include "llvm/Transforms/Instrumentation/MemProfiler.h"
 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
@@ -134,6 +135,8 @@ namespace clang {
 extern llvm::cl::opt<bool> ClSanitizeGuardChecks;
 }
 
+static cl::opt<bool> FilCKillUB(
+  "filc-killub", cl::desc("Run the KillUB pass"), cl::Hidden, cl::init(true));
 static cl::opt<bool> FilCOptimize(
   "filc-optimize", cl::desc("Run Fil-C optimization pipeline"), cl::Hidden, cl::init(true));
 static cl::opt<bool> FilCInline(
@@ -1040,6 +1043,8 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
 
     PB.registerPipelineStartEPCallback(
         [](ModulePassManager &MPM, OptimizationLevel Level) {
+          if (FilCKillUB)
+            MPM.addPass(KillUBPass());
           if (Level != OptimizationLevel::O0 && FilCOptimize) {
             FunctionPassManager EarlyFPM;
             EarlyFPM.addPass(LowerExpectIntrinsicPass());

filc/tests/nullub/manifest

@@ -0,0 +1,6 @@
+return:
+  success
+output-includes:
+  - "p is null"
+output-excludes:
+  - "p is not null"

filc/tests/nullub/nullub.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdfil.h>
+
+int main() {
+  void *p = zandptr((void *)1, ~1ULL);
+  if (p)
+    puts("p is not null");
+  else
+    puts("p is null");
+  return 0;
+}

filc/tests/strictaliasing/manifest

@@ -0,0 +1,2 @@
+return:
+  success

filc/tests/strictaliasing/strictaliasing.c

@@ -0,0 +1,16 @@
+#include <stdfil.h>
+
+static __attribute__((noinline)) int foo(int* p, float* q)
+{
+    int x = *p;
+    *q = 0;
+    return x + *p;
+}
+
+int main()
+{
+    int x = 42;
+    ZASSERT(foo(&x, (float*)&x) == 42);
+    return 0;
+}
+

llvm/include/llvm/Transforms/Instrumentation/KillUB.h

@@ -0,0 +1,19 @@
+#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_KILLUB_H
+#define LLVM_TRANSFORMS_INSTRUMENTATION_KILLUB_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Module;
+
+class KillUBPass : public PassInfoMixin<KillUBPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+  static bool isRequired() { return true; }
+};
+
+} // namespace llvm
+
+#endif /* LLVM_TRANSFORMS_INSTRUMENTATION_KILLUB_H */
+

llvm/lib/Transforms/Instrumentation/CMakeLists.txt

@@ -14,6 +14,7 @@ add_llvm_component_library(LLVMInstrumentation
   InstrOrderFile.cpp
   InstrProfiling.cpp
   KCFI.cpp
+  KillUB.cpp
   LowerAllowCheckPass.cpp
   PGOCtxProfFlattening.cpp
   PGOCtxProfLowering.cpp

llvm/lib/Transforms/Instrumentation/FilPizlonator.cpp

@@ -6,22 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file is a part of Fil-C.
-//
-// See here for an overview:
-// https://github.com/pizlonator/llvm-project-deluge/blob/deluge/Manifesto.md
-//
-// This document explains the semantics we're trying to achieve:
-// https://github.com/pizlonator/llvm-project-deluge/blob/deluge/gimso_semantics.md
-//
-// Here is a non-exhaustive set of examples of issues this catches:
-// https://github.com/pizlonator/llvm-project-deluge/blob/deluge/invisicaps_by_example.md
-//
-// And and explanation of the disassembly:
-// https://github.com/pizlonator/llvm-project-deluge/blob/deluge/test43.md
-//
-// This pass strongly relies on the Fil-C runtime and FUGC garbage collector.
-// Those components are in the llvm-project/libpas directory.
+// This file is a part of Fil-C. https://fil-c.org/
 //
 //===----------------------------------------------------------------------===//
 

llvm/lib/Transforms/Instrumentation/KillUB.cpp

@@ -0,0 +1,75 @@
+//===- KillUB.cpp - remove all UB flags -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of Fil-C. https://fil-c.org/
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Instrumentation/KillUB.h"
+
+#include <llvm/IR/AttributeMask.h>
+#include <llvm/IR/InlineAsm.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/Operator.h>
+
+using namespace llvm;
+
+PreservedAnalyses KillUBPass::run(Module &M, ModuleAnalysisManager&) {
+  // This is just the beginning! There are probably more UB killings that have to happen.
+  
+  AttributeMask AM;
+  AM.addAttribute(Attribute::AllocSize);
+  AM.addAttribute(Attribute::NoUndef);
+  AM.addAttribute(Attribute::Convergent);
+  AM.addAttribute(Attribute::Dereferenceable);
+  AM.addAttribute(Attribute::DereferenceableOrNull);
+  AM.addAttribute(Attribute::Memory);
+  AM.addAttribute(Attribute::NoAlias);
+  AM.addAttribute(Attribute::NoCallback);
+  AM.addAttribute(Attribute::NoCapture);
+  AM.addAttribute(Attribute::Captures);
+  AM.addAttribute(Attribute::NoDivergenceSource);
+  AM.addAttribute(Attribute::NoExt);
+  AM.addAttribute(Attribute::NoFree);
+  AM.addAttribute(Attribute::DeadOnUnwind);
+  AM.addAttribute(Attribute::NonNull);
+  AM.addAttribute(Attribute::NoRecurse);
+  AM.addAttribute(Attribute::NoRedZone);
+  AM.addAttribute(Attribute::NoReturn);
+  AM.addAttribute(Attribute::NoSync);
+  AM.addAttribute(Attribute::Range);
+  AM.addAttribute(Attribute::ReadNone);
+  AM.addAttribute(Attribute::ReadOnly);
+  AM.addAttribute(Attribute::Returned);
+  AM.addAttribute(Attribute::Returned);
+  AM.addAttribute(Attribute::WillReturn);
+  AM.addAttribute(Attribute::Writable);
+  AM.addAttribute(Attribute::WriteOnly);
+  AM.addAttribute(Attribute::MustProgress);
+
+  for (Function& F : M) {
+    if (F.isIntrinsic()) {
+      assert(F.isDeclaration());
+      continue;
+    }
+    F.removeFnAttrs(AM);
+    F.removeRetAttrs(AM);
+    for (size_t Idx = F.arg_size(); Idx--;)
+      F.removeParamAttrs(Idx, AM);
+    for (BasicBlock& BB : F) {
+      for (Instruction& I : BB) {
+        I.dropUnknownNonDebugMetadata();
+        I.dropPoisonGeneratingAnnotations();
+        I.dropUBImplyingAttrsAndUnknownMetadata();
+      }
+    }
+  }
+  
+  return PreservedAnalyses::none();
+}
+