+ modify runtime check insertion for bounds cast operation (checkedc#256)

  + dynamic_bounds_cast operation SHOULD always succeed if runtime value of subexpression of cast is NULL(0)
  it finally emits dynamic_check(E == NULL || (lb <= castlb && castub <= ub))
  it checks if subexpression value is NULL
  if subexpression value is not NULL, then it emits range bounds check code
  Otherwise(E == NULL), it skips range bounds check
  range bounds check is generated only if E is not NULL

  generated code is as follows:
  if (E == NULL) {
success_block:
  }
  else {
fallthrough_block:
    if (lb <= castlb && castub <= ub) {
success_block:
    }
    else {
fail_block:
      trap(); llvm_unreachable();
    }
  }

  To check this code, we have checked generated llvm IR code for test code & modified test code

Author: wonsubkim

include/clang/AST/Expr.h

@@ -2798,8 +2798,9 @@ class BoundsExpr : public Expr {
 /// classes).
 class CastExpr : public Expr {
 private:
-  // CASTBOUNDS - for expanded bounds of cast expression
-  // SUBEXPRBOUNDS - for bounds of subexpression
+  // BOUNDS - declared bounds of the result of the cast expression
+  // CASTBOUNDS - inferred bounds of cast expression
+  // SUBEXPRBOUNDS - inferred bounds of subexpression
   enum { OP, BOUNDS, CASTBOUNDS, SUBEXPRBOUNDS, END_EXPR = 4 };
   Stmt* SubExprs[END_EXPR];
 

lib/CodeGen/CGDynamicCheck.cpp

@@ -141,6 +141,36 @@ void CodeGenFunction::EmitDynamicBoundsCheck(const Address BaseAddr,
 
   ++NumDynamicChecksRange;
 
+  // Dynamic_check(Base == NULL || (Lower <= CastLower && CastUpper <= Upper))
+  // Emit code blocks as follows:
+  // if (Base == NULL) {...}
+  // else {
+  // if (Lower <= CastLower && CastUpper <= Upper) {...}
+  // else { trap(); llvm_unreachable(); }
+  // }
+
+  Value *Cond1 =
+            Builder.CreateIsNull(BaseAddr.getPointer(), "_Dynamic_check.null");
+
+  // Constant Folding:
+  // If we have generated a constant condition, and the condition is true,
+  // then the check will always pass and we can elide it.
+  if (const ConstantInt *ConditionConstant = dyn_cast<ConstantInt>(Cond1)) {
+    if (ConditionConstant->isOne()) {
+      ++NumDynamicChecksElided;
+      return;
+    }
+  }
+
+  ++NumDynamicChecksInserted;
+
+  BasicBlock *Begin, *DyCkSuccess, *DyCkFail, *DyCkFallThrough;
+  Begin = Builder.GetInsertBlock();
+  DyCkSuccess = createBasicBlock("_Dynamic_check.succeeded");
+  DyCkFallThrough = createBasicBlock("_Dynamic_check.fallthrough", this->CurFn);
+  DyCkFail = createBasicBlock("_Dynamic_check.failed", this->CurFn);
+
+  Builder.SetInsertPoint(DyCkFallThrough);
   // SubRange - bounds(lb, ub) vs CastRange - bounds(castlb, castub)
   // Dynamic_check(lb <= castlb && castub <= ub)
 
@@ -169,38 +199,8 @@ void CodeGenFunction::EmitDynamicBoundsCheck(const Address BaseAddr,
   Value *UpperChk =
       Builder.CreateICmpULE(CastUpperInt, UpperInt, "_Dynamic_check.upper_cmp");
 
-  // if expression E is NULL, skip dynamic_check
-  // Dynamic_check(E == NULL || (lb <= castlb && castub <= ub))
-  // if (cond1) {...}
-  // else {
-  // if (cond2) {...}
-  // else { trap(); llvm_unreachable(); }
-  // }
-  EmitDynamicCheckBlocks(
-      Builder.CreateIsNull(BaseAddr.getPointer(), "_Dynamic_check.null"),
-      Builder.CreateAnd(LowerChk, UpperChk, "_Dynamic_check.range"));
-}
-
-void CodeGenFunction::EmitDynamicCheckBlocks(Value *Condition) {
-  assert(Condition->getType()->isIntegerTy(1) &&
-         "May only dynamic check boolean conditions");
-
-  // Constant Folding:
-  // If we have generated a constant condition, and the condition is true,
-  // then the check will always pass and we can elide it.
-  if (const ConstantInt *ConditionConstant = dyn_cast<ConstantInt>(Condition)) {
-    if (ConditionConstant->isOne()) {
-      ++NumDynamicChecksElided;
-      return;
-    }
-  }
-
-  ++NumDynamicChecksInserted;
-
-  BasicBlock *Begin, *DyCkSuccess, *DyCkFail;
-  Begin = Builder.GetInsertBlock();
-  DyCkSuccess = createBasicBlock("_Dynamic_check.succeeded");
-  DyCkFail = createBasicBlock("_Dynamic_check.failed", this->CurFn);
+  Value *Cond2 = Builder.CreateAnd(LowerChk, UpperChk, "_Dynamic_check.range");
+  Builder.CreateCondBr(Cond2, DyCkSuccess, DyCkFail);
 
   Builder.SetInsertPoint(DyCkFail);
   CallInst *TrapCall = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::trap));
@@ -209,22 +209,21 @@ void CodeGenFunction::EmitDynamicCheckBlocks(Value *Condition) {
   Builder.CreateUnreachable();
 
   Builder.SetInsertPoint(Begin);
-  Builder.CreateCondBr(Condition, DyCkSuccess, DyCkFail);
+  Builder.CreateCondBr(Cond1, DyCkSuccess, DyCkFallThrough);
   // This ensures the success block comes directly after the branch
   EmitBlock(DyCkSuccess);
 
   Builder.SetInsertPoint(DyCkSuccess);
 }
 
-// emit code for dynamic_check(cond1 || cond2)
-void CodeGenFunction::EmitDynamicCheckBlocks(Value *Cond1, Value *Cond2) {
-  assert(Cond1->getType()->isIntegerTy(1) &&
+void CodeGenFunction::EmitDynamicCheckBlocks(Value *Condition) {
+  assert(Condition->getType()->isIntegerTy(1) &&
          "May only dynamic check boolean conditions");
 
   // Constant Folding:
   // If we have generated a constant condition, and the condition is true,
   // then the check will always pass and we can elide it.
-  if (const ConstantInt *ConditionConstant = dyn_cast<ConstantInt>(Cond1)) {
+  if (const ConstantInt *ConditionConstant = dyn_cast<ConstantInt>(Condition)) {
     if (ConditionConstant->isOne()) {
       ++NumDynamicChecksElided;
       return;
@@ -233,36 +232,22 @@ void CodeGenFunction::EmitDynamicCheckBlocks(Value *Cond1, Value *Cond2) {
 
   ++NumDynamicChecksInserted;
 
-  // if (cond1) {...}
-  // else {
-  // if (cond2) {...}
-  // else { trap(); llvm_unreachable(); }
-  // }
-
-  BasicBlock *Begin, *DyCkSuccess, *DyCkFail, *DyCkFallThrough;
+  BasicBlock *Begin, *DyCkSuccess, *DyCkFail;
   Begin = Builder.GetInsertBlock();
   DyCkSuccess = createBasicBlock("_Dynamic_check.succeeded");
-  DyCkFallThrough = createBasicBlock("_Dynamic_check.fallthrough", this->CurFn);
   DyCkFail = createBasicBlock("_Dynamic_check.failed", this->CurFn);
 
-  // if (cond1) Success
-  // else { FallThrough
-  // if (cond2) Success
-  // else { Fail, trap; llvm_unreachable; }
-  // }
-  Builder.SetInsertPoint(DyCkFallThrough);
-  Builder.CreateCondBr(Cond2, DyCkSuccess, DyCkFail);
-
   Builder.SetInsertPoint(DyCkFail);
   CallInst *TrapCall = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::trap));
   TrapCall->setDoesNotReturn();
   TrapCall->setDoesNotThrow();
   Builder.CreateUnreachable();
 
   Builder.SetInsertPoint(Begin);
-  Builder.CreateCondBr(Cond1, DyCkSuccess, DyCkFallThrough);
+  Builder.CreateCondBr(Condition, DyCkSuccess, DyCkFail);
   // This ensures the success block comes directly after the branch
   EmitBlock(DyCkSuccess);
 
   Builder.SetInsertPoint(DyCkSuccess);
 }
+

lib/CodeGen/CodeGenFunction.h

@@ -2294,8 +2294,6 @@ class CodeGenFunction : public CodeGenTypeCache {
   /// \brief Create a basic block that will call the trap intrinsic, and emit
   /// a conditional branch to it, for Checked C's dynamic checks.
   void EmitDynamicCheckBlocks(llvm::Value *Condition);
-  /// Emit code blocks for dynamic_check(cond1 || cond2)
-  void EmitDynamicCheckBlocks(llvm::Value *Cond1, llvm::Value *Cond2);
 
   llvm::Value *EmitBoundsCast(CastExpr *CE);