thread_safety and uninitialized_checks attributes

[kcc]

Summary

Adding two new function attributes: thread_safety and uninitialized_checks.
They will be used by tsan/msan the same way as
address_safety attribute is used by asan.

Also fix Bitcode/Reader/BitcodeReader (and Writer)
to allow attributes above 1ULL<<36

See http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20130204/164388.html for the discussion.

With later patches I will add the corresponding user attribute attribute(uninitialized_checks).
There is already an existing attribute attribute(no_thread_safety_analysis)

Naming is hard. I'd be glad to hear a better alternative for the "uninitialized_checks" attribute name.

[void]

This looks good. Thanks!

[Eugene.Zelenko]

Committed in rL174864.

docs/LangRef.rst

     If a function that has an ``sspstrong`` attribute is inlined into a
     function that doesn't have an ``sspstrong`` attribute, then the
     resulting function will have an ``sspstrong`` attribute.
+``thread_safety``
+    This attribute indicates that the thread safety analysis is enabled
+    for this function.
+``uninitialized_checks``
+    This attribute indicates that the checks for uses of uninitialized
+    memory are enabled.
 ``uwtable``
     This attribute indicates that the ABI being targeted requires that
     an unwind table entry be produce for this function even if we can

include/llvm/IR/Attributes.h

     StackProtectReq,       ///< Stack protection required.
     StackProtectStrong,    ///< Strong Stack protection.
     StructRet,             ///< Hidden pointer to structure to return
+    ThreadSafety,          ///< Thread safety checking is on.
+    UninitializedChecks,   ///< Checking for uses of uninitialized memory is on.
     UWTable,               ///< Function must be in a unwind table
     ZExt,                  ///< Zero extended before/after call
 

       .removeAttribute(Attribute::NonLazyBind)
       .removeAttribute(Attribute::ReturnsTwice)
       .removeAttribute(Attribute::AddressSafety)
+      .removeAttribute(Attribute::ThreadSafety)
+      .removeAttribute(Attribute::UninitializedChecks)
       .removeAttribute(Attribute::MinSize)
       .removeAttribute(Attribute::NoDuplicate);
   }

lib/AsmParser/LLLexer.cpp

   KEYWORD(ssp);
   KEYWORD(sspreq);
   KEYWORD(sspstrong);
+  KEYWORD(thread_safety);
+  KEYWORD(uninitialized_checks);
   KEYWORD(uwtable);
   KEYWORD(zeroext);
 

lib/AsmParser/LLParser.cpp

     case lltok::kw_ssp:             B.addAttribute(Attribute::StackProtect); break;
     case lltok::kw_sspreq:          B.addAttribute(Attribute::StackProtectReq); break;
     case lltok::kw_sspstrong:       B.addAttribute(Attribute::StackProtectStrong); break;
+    case lltok::kw_thread_safety:   B.addAttribute(Attribute::ThreadSafety); break;
+    case lltok::kw_uninitialized_checks: B.addAttribute(Attribute::UninitializedChecks); break;
     case lltok::kw_uwtable:         B.addAttribute(Attribute::UWTable); break;
 
     // Error handling.

     case lltok::kw_noredzone:      case lltok::kw_noimplicitfloat:
     case lltok::kw_naked:          case lltok::kw_nonlazybind:
     case lltok::kw_address_safety: case lltok::kw_minsize:
-    case lltok::kw_alignstack:
+    case lltok::kw_alignstack:     case lltok::kw_thread_safety:
+    case lltok::kw_uninitialized_checks:
       HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
       break;
     }

     case lltok::kw_nonlazybind:    case lltok::kw_address_safety:
     case lltok::kw_minsize:        case lltok::kw_alignstack:
     case lltok::kw_align:          case lltok::kw_noduplicate:
+    case lltok::kw_thread_safety:  case lltok::kw_uninitialized_checks:
       HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
       break;
     }

lib/AsmParser/LLToken.h

     kw_sspreq,
     kw_sspstrong,
     kw_sret,
+    kw_thread_safety,
+    kw_uninitialized_checks,
     kw_uwtable,
     kw_zeroext,
 

lib/Bitcode/Reader/BitcodeReader.cpp

 
   if (Alignment)
     B.addAlignmentAttr(Alignment);
-  B.addRawValue(((EncodedAttrs & (0xffffULL << 32)) >> 11) |
+  B.addRawValue(((EncodedAttrs & (0xfffffULL << 32)) >> 11) |
                 (EncodedAttrs & 0xffff));
 }
 

lib/Bitcode/Writer/BitcodeWriter.cpp

   uint64_t EncodedAttrs = Attrs.Raw(Index) & 0xffff;
   if (Attrs.hasAttribute(Index, Attribute::Alignment))
     EncodedAttrs |= Attrs.getParamAlignment(Index) << 16;
-  EncodedAttrs |= (Attrs.Raw(Index) & (0xffffULL << 21)) << 11;
+  EncodedAttrs |= (Attrs.Raw(Index) & (0xfffffULL << 21)) << 11;
   return EncodedAttrs;
 }
 

lib/IR/Attributes.cpp

     return "sspstrong";
   if (hasAttribute(Attribute::StructRet))
     return "sret";
+  if (hasAttribute(Attribute::ThreadSafety))
+    return "thread_safety";
+  if (hasAttribute(Attribute::UninitializedChecks))
+    return "uninitialized_checks";
   if (hasAttribute(Attribute::UWTable))
     return "uwtable";
   if (hasAttribute(Attribute::ZExt))

   case Attribute::MinSize:         return 1ULL << 33;
   case Attribute::NoDuplicate:     return 1ULL << 34;
   case Attribute::StackProtectStrong: return 1ULL << 35;
+  case Attribute::ThreadSafety:    return 1ULL << 36;
+  case Attribute::UninitializedChecks: return 1ULL << 37;
   }
   llvm_unreachable("Unsupported attribute type");
 }

lib/IR/Verifier.cpp

           !Attrs.hasAttribute(Idx, Attribute::NonLazyBind) &&
           !Attrs.hasAttribute(Idx, Attribute::ReturnsTwice) &&
           !Attrs.hasAttribute(Idx, Attribute::AddressSafety) &&
+          !Attrs.hasAttribute(Idx, Attribute::ThreadSafety) &&
+          !Attrs.hasAttribute(Idx, Attribute::UninitializedChecks) &&
           !Attrs.hasAttribute(Idx, Attribute::MinSize),
           "Some attributes in '" + Attrs.getAsString(Idx) +
           "' only apply to functions!", V);

test/Bitcode/attributes.ll

 {
         ret void;
 }
+define void @f28() thread_safety
+; CHECK: define void @f28() thread_safety
+{
+        ret void;
+}
+define void @f29() uninitialized_checks
+; CHECK: define void @f29() uninitialized_checks
+{
+        ret void;
+}

utils/llvm.grm

  | returns_twice
  | nonlazybind
  | address_safety
+ | thread_safety
+ | uninitialized_checks
  ;
 
 OptFuncAttrs  ::= + _ | OptFuncAttrs FuncAttr ;

utils/vim/llvm.vim

 syn keyword llvmKeyword sspstrong tail target thread_local to triple
 syn keyword llvmKeyword unnamed_addr unordered uwtable volatile weak weak_odr
 syn keyword llvmKeyword x86_fastcallcc x86_stdcallcc x86_thiscallcc zeroext
+syn keyword llvmKeyword thread_safety uninitialized_checks
 
 " Obsolete keywords.
 syn keyword llvmError  getresult begin end