[Attr] Add support for the `ms_hook_prologue` attribute.

[cdavis5x]

Summary

Based on a patch by Michael Mueller.

This attribute specifies that a function can be hooked or patched. This
mechanism was originally devised by Microsoft for hotpatching their
binaries (which they're constantly updating to stay ahead of crackers,
script kiddies, and other ne'er-do-wells on the Internet), but it's now
commonly abused by Windows programs that want to hook API functions. It
is for this reason that this attribute was added to GCC--hence the name,
ms_hook_prologue.

Depends on D19908.

[aaron.ballman]

Generally, I think this should make use of the patchable function functionality from D19046 when lowering, but I do have some comments on the attribute itself as well.

include/clang/Basic/Attr.td

2073

Does this attribute appertain to all targets, or only targets that MSVC supports?

2076

Please, no undocumented new attributes.

[cdavis5x]

• Use Sanjoy's patchable-function attribute.
• Add documentation for this new attribute.

[cdavis5x]

include/clang/Basic/Attr.td

2073

Only to CPUs that MSVC supports, but it works on all OSes--even non-Windows ones.

I should mention that this attribute was specifically added to GCC so Wine could use it.

[aaron.ballman]

The patch is missing semantic test cases. I would like to see tests of the attribute being accepted, as well as rejected because the subject was incorrect, args were provided, etc.

Also, I believe there are attributes which this attribute should not be combined with, such as __declspec(naked). I think we should diagnose in that case (MSVC does not because the entire object file is hotpatched, not individual functions). e.g., __declspec(naked) void f(void) __attribute__((ms_hook_prologue));

include/clang/Basic/Attr.td

2073

I am wondering whether we want this to be a target-specific attribute or not. Right now, this attribute will be silently accepted for CPUs that MSVC does not support, for instance. If we made the attribute target-specific, then users would get appropriate diagnostics for those architectures.

[cdavis5x]

• Add Sema tests for the ms_hook_prologue attribute.
• Disallow ms_hook_prologue on architectures that Windows doesn't support.
• Disallow ms_hook_prologue with the naked and always_inline attributes.

[cdavis5x]

For now, I've disallowed it with naked and always_inline/__forceinline attributes. Do any other attributes affect prologue generation in a way that might interfere with ms_hook_prologue? AFAICT, GCC only disallows ms_hook_prologue on a) nested functions and b) functions compiled with -mfentry (neither of which we support, AFAIK).

include/clang/Basic/Attr.td

2073

For now, I've limited it to architectures that Windows supports.

[aaron.ballman]

LGTM (when Sanjoy's patch goes in), with two minor nits.

Can you also add a test that the attribute fails on one of the target architectures Windows does not support?

include/clang/Basic/AttrDocs.td

560

Should document that we disallow it in conjunction with naked, always_inline, and __forceinline.

[cdavis5x]

Update for merge conflicts.

• Add a blurb to the docs advising against using this attribute with __forceinline, always_inline, or naked.

[cdavis5x]

include/clang/Basic/AttrDocs.td

560

Done.

include/clang/Basic/Attr.td

class TargetArch<list<string> arches> {
   list<string> OSes;
   list<string> CXXABIs;
 }
 def TargetARM : TargetArch<["arm", "thumb"]>;
 def TargetMips : TargetArch<["mips", "mipsel"]>;
 def TargetMSP430 : TargetArch<["msp430"]>;
 def TargetX86 : TargetArch<["x86"]>;
 def TargetAnyX86 : TargetArch<["x86", "x86_64"]>;
+def TargetWindowsArches : TargetArch<["x86", "x86_64", "arm", "thumb"]>;
 def TargetWindows : TargetArch<["x86", "x86_64", "arm", "thumb"]> {
   let OSes = ["Win32"];
 }
 def TargetMicrosoftCXXABI : TargetArch<["x86", "x86_64", "arm", "thumb"]> {
   let CXXABIs = ["Microsoft"];
 }
 
 class Attr {
let Args = [IdentifierArgument<"ArgumentKind">,
               BoolArgument<"MustBeNull">];
 //  let Subjects = SubjectList<[Var], ErrorDiag>;
   let HasCustomParsing = 1;
   let Documentation = [TypeTagForDatatypeDocs];
 }
 
 // Microsoft-related attributes
 
+def MSHookPrologue : InheritableAttr, TargetSpecificAttr<TargetWindowsArches> {
+  let Spellings = [GCC<"ms_hook_prologue">];
+  let Subjects = SubjectList<[Function]>;
+  let Documentation = [MSHookPrologueDocs];
+}
+
 def MSNoVTable : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> {
   let Spellings = [Declspec<"novtable">];
   let Subjects = SubjectList<[CXXRecord]>;
   let Documentation = [MSNoVTableDocs];
 }
 
 def : IgnoredAttr {
   let Spellings = [Declspec<"property">];

include/clang/Basic/AttrDocs.td

 merely want to document its non-standard retain and release semantics, should
 use the retaining behavior attributes (``ns_returns_retained``,
 ``ns_returns_not_retained``, etc).
 
 Query for this feature with ``__has_attribute(objc_method_family)``.
   }];
 }
 
+def MSHookPrologueDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``ms_hook_prologue`` attribute marks a function as "hotpatchable" according
+to conventions used on Windows. Specifically, enough space will be ensured
+in the prologue for a short jump, and an architecturally dependently sized
+patch space will be reserved prior to the entry point. See the documentation
+for the `/HOTPATCH`_ switch on MSDN.
+
+This attribute cannot be used in conjunction with the ``naked``,
+``always_inline``, or ``__forceinline`` attributes.
+
+.. _`/HOTPATCH`: https://msdn.microsoft.com/en-us/library/ms173507.aspx
+  }];
+}
+
 def NoDebugDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{
 The ``nodebug`` attribute allows you to suppress debugging information for a
 function or method, or for a variable that is not a parameter or a non-static
 data member.
   }];
 }

lib/CodeGen/TargetInfo.cpp

if (FD->hasAttr<X86ForceAlignArgPointerAttr>()) {
                       llvm::AttributeSet::get(CGM.getLLVMContext(),
                                               llvm::AttributeSet::FunctionIndex,
                                               B));
     }
     if (FD->hasAttr<AnyX86InterruptAttr>()) {
       llvm::Function *Fn = cast<llvm::Function>(GV);
       Fn->setCallingConv(llvm::CallingConv::X86_INTR);
     }
+    if (FD->hasAttr<MSHookPrologueAttr>()) {
+      llvm::Function *Fn = cast<llvm::Function>(GV);
+      Fn->addFnAttr("patchable-function", "ms-hotpatch");
+    }
   }
 }
 
 bool X86_32TargetCodeGenInfo::initDwarfEHRegSizeTable(
                                                CodeGen::CodeGenFunction &CGF,
                                                llvm::Value *Address) const {
   CodeGen::CGBuilderTy &Builder = CGF.Builder;
 
public:
 
   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
                            CodeGen::CodeGenModule &CGM) const override {
     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) {
       if (FD->hasAttr<AnyX86InterruptAttr>()) {
         llvm::Function *Fn = cast<llvm::Function>(GV);
         Fn->setCallingConv(llvm::CallingConv::X86_INTR);
       }
+      if (FD->hasAttr<MSHookPrologueAttr>()) {
+        llvm::Function *Fn = cast<llvm::Function>(GV);
+        Fn->addFnAttr("patchable-function", "ms-hotpatch");
+      }
     }
   }
 };
 
 class PS4TargetCodeGenInfo : public X86_64TargetCodeGenInfo {
 public:
   PS4TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, X86AVXABILevel AVXLevel)
     : X86_64TargetCodeGenInfo(CGT, AVXLevel) {}

lib/Sema/SemaDeclAttr.cpp

if (S.LangOpts.CPlusPlus) {
     return;
   }
 
   if (CommonAttr *CA = S.mergeCommonAttr(D, Attr.getRange(), Attr.getName(),
                                          Attr.getAttributeSpellingListIndex()))
     D->addAttr(CA);
 }
 
-static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
-  if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, Attr.getRange(),
-                                                     Attr.getName()))
-    return;
-
-  D->addAttr(::new (S.Context) NakedAttr(Attr.getRange(), S.Context,
-                                         Attr.getAttributeSpellingListIndex()));
-}
-
 static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
   if (hasDeclarator(D)) return;
 
   if (S.CheckNoReturnAttr(attr)) return;
 
   if (!isa<ObjCMethodDecl>(D)) {
     S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
       << attr.getName() << ExpectedFunctionOrMethod;
OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
 
   return ::new (Context) OptimizeNoneAttr(Range, Context,
                                           AttrSpellingListIndex);
 }
 
 static void handleAlwaysInlineAttr(Sema &S, Decl *D,
                                    const AttributeList &Attr) {
   if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, Attr.getRange(),
+                                                  Attr.getName()) ||
+      checkAttrMutualExclusion<MSHookPrologueAttr>(S, D, Attr.getRange(),
                                                    Attr.getName()))
     return;
 
   if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
           D, Attr.getRange(), Attr.getName(),
           Attr.getAttributeSpellingListIndex()))
     D->addAttr(Inline);
 }
 
case AttributeList::AT_Ownership:
     break;
   case AttributeList::AT_Cold:
     handleColdAttr(S, D, Attr);
     break;
   case AttributeList::AT_Hot:
     handleHotAttr(S, D, Attr);
     break;
   case AttributeList::AT_Naked:
-    handleNakedAttr(S, D, Attr);
+    handleSimpleAttributeWithExclusions<NakedAttr, DisableTailCallsAttr,
+                                        MSHookPrologueAttr>(S, D, Attr);
     break;
   case AttributeList::AT_NoReturn:
     handleNoReturnAttr(S, D, Attr);
     break;
   case AttributeList::AT_NoThrow:
     handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
     break;
   case AttributeList::AT_CUDAShared:
case AttributeList::AT_LTOVisibilityPublic:
     break;
 
   // Microsoft attributes:
   case AttributeList::AT_EmptyBases:
     handleSimpleAttribute<EmptyBasesAttr>(S, D, Attr);
     break;
   case AttributeList::AT_LayoutVersion:
     handleLayoutVersion(S, D, Attr);
+  case AttributeList::AT_MSHookPrologue:
+    handleSimpleAttributeWithExclusions<MSHookPrologueAttr, NakedAttr,
+      AlwaysInlineAttr>(S, D, Attr);
     break;
   case AttributeList::AT_MSNoVTable:
     handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
     break;
   case AttributeList::AT_MSStruct:
     handleSimpleAttribute<MSStructAttr>(S, D, Attr);
     break;
   case AttributeList::AT_Uuid:

test/CodeGen/function-attributes.c

 // CHECK: call i32 @_setjmp(i32* null)
 // CHECK: [[RT_CALL]]
 // CHECK: ret void
 int _setjmp(jmp_buf);
 void f20(void) {
   _setjmp(0);
 }
 
+// CHECK-LABEL: define void @f21
+// CHECK: [[HOTPATCH:#[0-9]+]]
+// CHECK: {
+void __attribute__((ms_hook_prologue)) f21(void) {
+}
+
 // CHECK: attributes [[NUW]] = { nounwind optsize{{.*}} }
 // CHECK: attributes [[AI]] = { alwaysinline nounwind optsize{{.*}} }
 // CHECK: attributes [[NUW_OS_RN]] = { nounwind optsize readnone{{.*}} }
 // CHECK: attributes [[ALIGN]] = { nounwind optsize alignstack=16{{.*}} }
 // CHECK: attributes [[RT]] = { nounwind optsize returns_twice{{.*}} }
+// CHECK: attributes [[HOTPATCH]] = { nounwind optsize{{.*}}"patchable-function"="ms-hotpatch"{{.*}} }
 // CHECK: attributes [[NR]] = { noreturn optsize }
 // CHECK: attributes [[NUW_RN]] = { nounwind optsize readnone }
 // CHECK: attributes [[RT_CALL]] = { optsize returns_twice }

test/Sema/attr-ms-hook-prologue-wrong-arch.c

+// RUN: %clang_cc1 -triple s390x-unknown-linux -fms-extensions -fsyntax-only -verify %s
+
+// expected-warning@+1{{unknown attribute 'ms_hook_prologue' ignored}}
+int __attribute__((ms_hook_prologue)) foo(int a, int b) {
+  return a+b;
+}

test/Sema/attr-ms-hook-prologue.c

+// RUN: %clang_cc1 -triple i386-pc-linux -fms-extensions -fsyntax-only -verify %s
+
+int __attribute__((ms_hook_prologue)) foo(int a, int b) {
+  return a+b;
+}
+
+// expected-note@+2{{conflicting attribute is here}}
+// expected-error@+1{{'naked' and 'ms_hook_prologue' attributes are not compatible}}
+__declspec(naked) int __attribute__((ms_hook_prologue)) bar(int a, int b) {
+}
+
+// expected-note@+2{{conflicting attribute is here}}
+// expected-error@+1{{'__forceinline' and 'ms_hook_prologue' attributes are not compatible}}
+__forceinline int __attribute__((ms_hook_prologue)) baz(int a, int b) {
+  return a-b;
+}
+
+// expected-warning@+1{{'ms_hook_prologue' attribute only applies to functions}}
+int x __attribute__((ms_hook_prologue));
+
+// expected-error@+1{{'ms_hook_prologue' attribute takes no arguments}}
+int f(int a, int b) __attribute__((ms_hook_prologue(2)));