[Attributor] Add support for compound assignment for ChangeStatus

[tianshilei1992]

Summary

A common use of ChangeStatus is as follows:

ChangeStatus Changed = ChangeStatus::UNCHANGED;
Changed |= foo();

where foo returns ChangeStatus as well. Currently ChangeStatus doesn't
support compound assignment, we have to write as

Changed = Changed | foo();

which is not that convenient.

This patch add the support for compound assignment for ChangeStatus. Compound
assignment is usually implemented as a member function, and binary arithmetic
operator is therefore implemented using compound assignment. However, unlike
regular C++ class, enum class doesn't support member functions. As a result, they
can only be implemented in the way shown in the patch.

[jdoerfert]

LG

Can you update the AttributorAttributes.cpp file too?

[tianshilei1992]

In D106109#2881887, @jdoerfert wrote:

Can you update the AttributorAttributes.cpp file too?

Didn't find any similar usage in AttributorAttributes.cpp?

llvm/include/llvm/Transforms/IPO/Attributor.h

 
 ///{
 enum class ChangeStatus {
   CHANGED,
   UNCHANGED,
 };
 
 ChangeStatus operator|(ChangeStatus l, ChangeStatus r);
+ChangeStatus &operator|=(ChangeStatus &l, ChangeStatus r);
 ChangeStatus operator&(ChangeStatus l, ChangeStatus r);
+ChangeStatus &operator&=(ChangeStatus &l, ChangeStatus r);
 
 enum class DepClassTy {
   REQUIRED, ///< The target cannot be valid if the source is not.
   OPTIONAL, ///< The target may be valid if the source is not.
   NONE,     ///< Do not track a dependence between source and target.
 };
 ///}
 

llvm/lib/Transforms/IPO/Attributor.cpp

PrintCallGraph("attributor-print-call-graph", cl::Hidden,
                    cl::init(false));
 
 /// Logic operators for the change status enum class.
 ///
 ///{
 ChangeStatus llvm::operator|(ChangeStatus L, ChangeStatus R) {
   return L == ChangeStatus::CHANGED ? L : R;
 }
+ChangeStatus &llvm::operator|=(ChangeStatus &L, ChangeStatus R) {
+  L = L | R;
+  return L;
+}
 ChangeStatus llvm::operator&(ChangeStatus L, ChangeStatus R) {
   return L == ChangeStatus::UNCHANGED ? L : R;
 }
+ChangeStatus &llvm::operator&=(ChangeStatus &L, ChangeStatus R) {
+  L = L & R;
+  return L;
+}
 ///}
 
 bool AA::isValidInScope(const Value &V, const Function *Scope) {
   if (isa<Constant>(V))
     return true;
   if (auto *I = dyn_cast<Instruction>(&V))
     return I->getFunction() == Scope;
   if (auto *A = dyn_cast<Argument>(&V))

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

A.registerSimplificationCallback(
         });
   }
 
   ChangeStatus updateImpl(Attributor &A) override {
     ChangeStatus Changed = ChangeStatus::UNCHANGED;
 
     switch (RFKind) {
     case OMPRTL___kmpc_is_spmd_exec_mode:
-      Changed = Changed | foldIsSPMDExecMode(A);
+      Changed |= foldIsSPMDExecMode(A);
       break;
     default:
       llvm_unreachable("Unhandled OpenMP runtime function!");
     }
 
     return Changed;
   }