mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-20 12:05:48 -04:00
7c192b452f
void foo(void) __attribute__((requires_capability((FlightControl || Worker) && !Logger))); This is WIP code. llvm-svn: 208439
113 lines
4.2 KiB
C++
113 lines
4.2 KiB
C++
//===- ThreadSafetyLogical.cpp ---------------------------------*- C++ --*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
// This file defines a representation for logical expressions with SExpr leaves
|
|
// that are used as part of fact-checking capability expressions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Analysis/Analyses/ThreadSafetyLogical.h"
|
|
|
|
using namespace llvm;
|
|
using namespace clang::threadSafety::lexpr;
|
|
|
|
// Implication. We implement De Morgan's Laws by maintaining LNeg and RNeg
|
|
// to keep track of whether LHS and RHS are negated.
|
|
static bool implies(const LExpr *LHS, bool LNeg, const LExpr *RHS, bool RNeg) {
|
|
// In comments below, we write => for implication.
|
|
|
|
// Calculates the logical AND implication operator.
|
|
const auto LeftAndOperator = [=](const BinOp *A) {
|
|
return implies(A->left(), LNeg, RHS, RNeg) &&
|
|
implies(A->right(), LNeg, RHS, RNeg);
|
|
};
|
|
const auto RightAndOperator = [=](const BinOp *A) {
|
|
return implies(LHS, LNeg, A->left(), RNeg) &&
|
|
implies(LHS, LNeg, A->right(), RNeg);
|
|
};
|
|
|
|
// Calculates the logical OR implication operator.
|
|
const auto LeftOrOperator = [=](const BinOp *A) {
|
|
return implies(A->left(), LNeg, RHS, RNeg) ||
|
|
implies(A->right(), LNeg, RHS, RNeg);
|
|
};
|
|
const auto RightOrOperator = [=](const BinOp *A) {
|
|
return implies(LHS, LNeg, A->left(), RNeg) ||
|
|
implies(LHS, LNeg, A->right(), RNeg);
|
|
};
|
|
|
|
// Recurse on right.
|
|
switch (RHS->kind()) {
|
|
case LExpr::And:
|
|
// When performing right recursion:
|
|
// C => A & B [if] C => A and C => B
|
|
// When performing right recursion (negated):
|
|
// C => !(A & B) [if] C => !A | !B [===] C => !A or C => !B
|
|
return RNeg ? RightOrOperator(cast<And>(RHS))
|
|
: RightAndOperator(cast<And>(RHS));
|
|
case LExpr::Or:
|
|
// When performing right recursion:
|
|
// C => (A | B) [if] C => A or C => B
|
|
// When performing right recursion (negated):
|
|
// C => !(A | B) [if] C => !A & !B [===] C => !A and C => !B
|
|
return RNeg ? RightAndOperator(cast<Or>(RHS))
|
|
: RightOrOperator(cast<Or>(RHS));
|
|
case LExpr::Not:
|
|
// Note that C => !A is very different from !(C => A). It would be incorrect
|
|
// to return !implies(LHS, RHS).
|
|
return implies(LHS, LNeg, cast<Not>(RHS)->exp(), !RNeg);
|
|
case LExpr::Terminal:
|
|
// After reaching the terminal, it's time to recurse on the left.
|
|
break;
|
|
}
|
|
|
|
// RHS is now a terminal. Recurse on Left.
|
|
switch (LHS->kind()) {
|
|
case LExpr::And:
|
|
// When performing left recursion:
|
|
// A & B => C [if] A => C or B => C
|
|
// When performing left recursion (negated):
|
|
// !(A & B) => C [if] !A | !B => C [===] !A => C and !B => C
|
|
return LNeg ? LeftAndOperator(cast<And>(LHS))
|
|
: LeftOrOperator(cast<And>(LHS));
|
|
case LExpr::Or:
|
|
// When performing left recursion:
|
|
// A | B => C [if] A => C and B => C
|
|
// When performing left recursion (negated):
|
|
// !(A | B) => C [if] !A & !B => C [===] !A => C or !B => C
|
|
return LNeg ? LeftOrOperator(cast<Or>(LHS))
|
|
: LeftAndOperator(cast<Or>(LHS));
|
|
case LExpr::Not:
|
|
// Note that A => !C is very different from !(A => C). It would be incorrect
|
|
// to return !implies(LHS, RHS).
|
|
return implies(cast<Not>(LHS)->exp(), !LNeg, RHS, RNeg);
|
|
case LExpr::Terminal:
|
|
// After reaching the terminal, it's time to perform identity comparisons.
|
|
break;
|
|
}
|
|
|
|
// A => A
|
|
// !A => !A
|
|
if (LNeg != RNeg)
|
|
return false;
|
|
|
|
// FIXME -- this should compare SExprs for equality, not pointer equality.
|
|
return cast<Terminal>(LHS)->expr() == cast<Terminal>(RHS)->expr();
|
|
}
|
|
|
|
namespace clang {
|
|
namespace threadSafety {
|
|
namespace lexpr {
|
|
|
|
bool implies(const LExpr *LHS, const LExpr *RHS) {
|
|
// Start out by assuming that LHS and RHS are not negated.
|
|
return ::implies(LHS, false, RHS, false);
|
|
}
|
|
}
|
|
}
|
|
}
|