[MTE] Add NT_ANDROID_TYPE_MEMTAG

[hctim]

Summary

This ELF note is aarch64 and Android-specific. It specifies to the
dynamic loader that specific work should be scheduled to enable MTE
protection of stack and heap regions.

Current synthesis of the ".note.android.memtag" ELF note is done in the
Android build system. We'd like to move that to the compiler, and this
is the first step.

[hctim]

Buggered up the endianness.

[jhenderson]

llvm/include/llvm/BinaryFormat/ELF.h

1564–1565

I guess the 2 value isn't used?

1574–1575

I guess values 5-7 aren't used?

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag/aarch64-note-memtag-all-async.test

1 ↗

(On Diff #407326)

Up to you, but I think it would be better to fold these tests into a single test case. You can then reduce duplication of the YAML in one of two ways - either by just having one of each note in the note section, or by using yaml2obj -D options to parameterise the YAML doc. There are plenty of examples of the latter in the llvm-readobj tests.

My comments in this test file also apply to the other files, if there's a strong motivation to keep them separate.

5 ↗

(On Diff #407326)

Nit: make things line up neatly to slightly improve readability.

34–35 ↗

(On Diff #407326)

We tend to remove excessive spacing in YAML, keeping values within the same block lined up vertically, at the minimum indentation.

llvm/tools/llvm-readobj/ELFDumper.cpp

5074–5075

It's probably necessary to have a test case that triggers this return false.

5077–5078

Ditto.

5091–5094

Needs test case for this label.

7117–7118

This and the GNU function are very similar structurally, which makes me think there's an opportunity for some code reuse here. If I'm not mistaken, the only difference is how these strings are printed? Could you have a helper function which returns a set of strings that are then passed to the corresponding print functions? I'm thinking something like the following sketch:

using std::unordered_map<StringRef, std::string> AndroidNoteProperties;
static Optional<AndroidNoteProperties> getAndroidNoteProperties(uint32_t NoteType, ArrayRef<uint8_t> Desc) {
  // Return None if we were unable to get the note properties.
  AndroidNoteProperties Props;
  switch (NoteType) {
  default:
     return None;
  case ELF::NT_ANDROID_TYPE_MEMTAG:
    if (Desc.empty())
      return None;

    switch (Desc[0] & NT_MEMTAG_LEVEL_MASK) {
    case NT_MEMTAG_LEVEL_NONE:
      Props["Tagging Mode"] = "NONE";
      break;
    case NT_MEMTAG_LEVEL_ASYNC:
      Props["Tagging Mode"] = "ASYNC";
      break;
    case NT_MEMTAG_LEVEL_SYNC:
      Props["Tagging Mode"] = "SYNC";
      break;
    default:
      Props["Tagging Mode"] =
          ("Unknown (" + Twine::utohexstr(Desc[0] & NT_MEMTAG_LEVEL_MASK) + ")")
              .str();
      break;
    }
    Props["Heap"] = (Desc[0] & NT_MEMTAG_HEAP) ? "Enabled" : "Disabled");
    Props["Stack"] = (Desc[0] & NT_MEMTAG_STACK) ? "Enabled" : "Disabled");
  }
  return Props;
}

template <typename ELFT>
static bool printAndroidNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
                                      ScopedPrinter &W) {
  // Return true if we were able to pretty-print the note, false otherwise.
  Optional<AndroidNoteProperties> Props = getAndroidNoteProperties(NoteType, Desc);
  if (!Props)
    return false;
  for(const auto &KV : Props)
    W.printString(KV.first, KV.second);
}

I don't know if the map will be general enough for future notes, but at least for this memtag note it certainly is. If we need to support other types, there may be a better structure, but I suggest waiting until then to worry about it.

[hctim]

llvm/include/llvm/BinaryFormat/ELF.h

1564–1565

Negative (https://cs.android.com/android/platform/superproject/+/master:bionic/libc/private/bionic_asm_note.h)

1574–1575

NT_MEMTAG_LEVEL_* are enum values, any NT_MEMTAG_HEAP/STACK are bitsets. Added some clarifying comments.

[hctim]

Addressing comments.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag/aarch64-note-android-memtag.test

1 ↗

(On Diff #408521)

You can drop "aarch64" from the test file names, since you're in the AArch64 folder. Probably also can drop "memtag", although I'd be more inclined to get rid of the subdirectory now, as there aren't that many(?) memtag tests now.

80 ↗

(On Diff #408521)

You should be able to do this and then omit "Desc: " from the -D values in the yaml2obj runs.

[hctim]

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag/aarch64-note-android-memtag.test

80 ↗

(On Diff #408521)

yaml2obj complained about Desc: \n when testing for INVALID (i.e. we don't want any description bytes), so I materialized the entire line as a -D parameter instead :).

[hctim]

Changed paths for tests.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/AArch64/memtag/aarch64-note-android-memtag.test

80 ↗

(On Diff #408521)

yaml2obj complained about Desc: \n when testing for INVALID (i.e. we don't want any description bytes), so I materialized the entire line as a -D parameter instead :).

llvm/test/tools/llvm-readobj/ELF/AArch64/note-android-memtag.test

81

yaml2obj complained about Desc: \n when testing for INVALID (i.e. we don't want any description bytes), so I materialized the entire line as a -D parameter instead :).

Ah, I missed that you omitted Desc entirely in the last case. For that case, you just need to provide empty quotes, I believe. The final YAML would look like Desc: ''. Of course, this means you'll need to do something about escaping the quotes on the lit commandline. An alternative approach is using the "<none>" approach, although I don't know if that works for the Desc field. See llvm/test/tools/yaml2obj/ELF/none-value.yaml for example usage: essentially, "<none>" set as the default value (i.e. [[DESC=<none>]]) means that the field is treated as not specified if a macro value is not provided on the command-line.

[hctim]

llvm/test/tools/llvm-readobj/ELF/AArch64/note-android-memtag.test

81

done, thanks for the "" pointer

[hctim]

~

[jhenderson]

Looks good from my point of view, but it might be worth seeing if someone with Android experience is able to review those details.

[hctim]

(+rprichard for android)

[MaskRay]

Let's wait for @rprichard.

llvm/tools/llvm-readobj/ELFDumper.cpp

5116

operator<<(char) compiles to less code.

[hctim]

Use operator<<(char)

[hctim]

Friendly ping @rprichard. For reference, I've been using this during development of MTE globals, and it synthesizes notes correctly for the (still WIP) patches: https://android-review.googlesource.com/c/platform/bionic/+/1845896

llvm/tools/llvm-readobj/ELFDumper.cpp

5116

neat trick!

[rprichard]

Yeah, I'm OK with this change. (I'm not really familiar with the MTE stuff.)

llvm/include/llvm/BinaryFormat/ELF.h

 enum {
   NT_GNU_ABI_TAG = 1,
   NT_GNU_HWCAP = 2,
   NT_GNU_BUILD_ID = 3,
   NT_GNU_GOLD_VERSION = 4,
   NT_GNU_PROPERTY_TYPE_0 = 5,
 };
 
+// Android note types.
+enum {
+  NT_ANDROID_TYPE_IDENT = 1,
+  NT_ANDROID_TYPE_KUSER = 3,
+  NT_ANDROID_TYPE_MEMTAG = 4,
+};
+
+// Memory tagging values used in NT_ANDROID_TYPE_MEMTAG notes.
+enum {
+  // Enumeration to determine the tagging mode. In Android-land, 'SYNC' means
+  // running all threads in MTE Synchronous mode, and 'ASYNC' means to use the
+  // kernels auto-upgrade feature to allow for either MTE Asynchronous,
+  // Asymmetric, or Synchronous mode. This allows silicon vendors to specify, on
+  // a per-cpu basis what 'ASYNC' should mean. Generally, the expectation is
+  // "pick the most precise mode that's very fast".
+  NT_MEMTAG_LEVEL_NONE = 0,
+  NT_MEMTAG_LEVEL_ASYNC = 1,
+  NT_MEMTAG_LEVEL_SYNC = 2,
+  NT_MEMTAG_LEVEL_MASK = 3,
+  // Bits indicating whether the loader should prepare for MTE to be enabled on
+  // the heap and/or stack.
+  NT_MEMTAG_HEAP = 4,
+  NT_MEMTAG_STACK = 8,
+};
+
 // Property types used in GNU_PROPERTY_TYPE_0 notes.
 enum : unsigned {
   GNU_PROPERTY_STACK_SIZE = 1,
   GNU_PROPERTY_NO_COPY_ON_PROTECTED = 2,
   GNU_PROPERTY_AARCH64_FEATURE_1_AND = 0xc0000000,
   GNU_PROPERTY_X86_FEATURE_1_AND = 0xc0000002,
 
   GNU_PROPERTY_X86_UINT32_OR_LO = 0xc0008000,

llvm/lib/ObjectYAML/ELFYAML.cpp

#define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(NT_AMD_HSA_CODE_OBJECT_VERSION);
   ECase(NT_AMD_HSA_HSAIL);
   ECase(NT_AMD_HSA_ISA_VERSION);
   ECase(NT_AMD_HSA_METADATA);
   ECase(NT_AMD_HSA_ISA_NAME);
   ECase(NT_AMD_PAL_METADATA);
   // AMDGPU specific notes. (Code Object V3)
   ECase(NT_AMDGPU_METADATA);
+  // Android specific notes.
+  ECase(NT_ANDROID_TYPE_IDENT);
+  ECase(NT_ANDROID_TYPE_KUSER);
+  ECase(NT_ANDROID_TYPE_MEMTAG);
 #undef ECase
   IO.enumFallback<Hex32>(Value);
 }
 
 void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(
     IO &IO, ELFYAML::ELF_EM &Value) {
 #define ECase(X) IO.enumCase(Value, #X, ELF::X)
   ECase(EM_NONE);

llvm/test/tools/llvm-readobj/ELF/AArch64/note-android-memtag.test

+# RUN: yaml2obj -D DESC='0d000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,ASYNC,HEAP,STACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,ASYNC,HEAP,STACK
+
+# RUN: yaml2obj -D DESC='0e000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,SYNC,HEAP,STACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,SYNC,HEAP,STACK
+
+# RUN: yaml2obj -D DESC='05000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,ASYNC,HEAP,NOSTACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,ASYNC,HEAP,NOSTACK
+
+# RUN: yaml2obj -D DESC='06000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,SYNC,HEAP,NOSTACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,SYNC,HEAP,NOSTACK
+
+# RUN: yaml2obj -D DESC='09000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,ASYNC,NOHEAP,STACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,ASYNC,NOHEAP,STACK
+
+# RUN: yaml2obj -D DESC='0a000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,SYNC,NOHEAP,STACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,SYNC,NOHEAP,STACK
+
+# RUN: yaml2obj -D DESC='03000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,UNKNOWN,NOHEAP,NOSTACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,UNKNOWN,NOHEAP,NOSTACK
+
+# RUN: yaml2obj -D DESC='00000000' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-OK,NONE,NOHEAP,NOSTACK
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-OK,NONE,NOHEAP,NOSTACK
+
+# RUN: yaml2obj -D DESC='""' %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU,GNU-BAD,INVALID
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM,LLVM-BAD,INVALID
+
+# GNU:          Displaying notes found in: .note.android.memtag
+# GNU-NEXT:     Owner    Data size   Description
+# GNU-OK-NEXT:  Android  0x00000004  NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)
+# GNU-BAD-NEXT: Android  0x00000000  NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)
+
+# LLVM:      Notes [
+# LLVM-NEXT:   NoteSection {
+# LLVM-NEXT:     Name: .note.android.memtag
+# LLVM-NEXT:     Offset: 0x40
+# LLVM-OK-NEXT:  Size: 0x18
+# LLVM-BAD-NEXT: Size: 0x14
+# LLVM-NEXT:     Note {
+# LLVM-NEXT:       Owner: Android
+# LLVM-OK-NEXT:    Data size: 0x4
+# LLVM-BAD-NEXT:   Data size: 0x0
+# LLVM-NEXT:       Type: NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)
+
+## Hint: Also used for the GNU tests.
+# INVALID-NEXT:    Invalid .note.android.memtag
+# NONE-NEXT:       Tagging Mode: NONE
+# ASYNC-NEXT:      Tagging Mode: ASYNC
+# SYNC-NEXT:       Tagging Mode: SYNC
+# UNKNOWN-NEXT:    Tagging Mode: Unknown (3)
+# HEAP-NEXT:       Heap: Enabled
+# NOHEAP-NEXT:     Heap: Disabled
+# STACK-NEXT:      Stack: Enabled
+# NOSTACK-NEXT:    Stack: Disabled
+
+# LLVM-NEXT:     }
+# LLVM-NEXT:   }
+# LLVM-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name: .note.android.memtag
+    Type: SHT_NOTE
+    Notes:
+      - Name: Android
+        Type: NT_ANDROID_TYPE_MEMTAG
+        Desc: [[DESC]]

llvm/test/tools/llvm-readobj/ELF/AArch64/note-android-unknown.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readelf --notes %t | FileCheck %s --check-prefixes=GNU
+# RUN: llvm-readobj --notes %t | FileCheck %s --check-prefixes=LLVM
+
+# GNU:      Displaying notes found in: .note.android.unknown
+# GNU-NEXT: Owner    Data size   Description
+# GNU-NEXT: Android  0x00000005  Unknown note type: (0x00001337)
+# GNU-NEXT: description data: 01 23 45 67 89
+
+# LLVM:      Notes [
+# LLVM-NEXT:   NoteSection {
+# LLVM-NEXT:     Name: .note.android.unknown
+# LLVM-NEXT:     Offset: 0x40
+# LLVM-NEXT:     Size: 0x1C
+# LLVM-NEXT:     Note {
+# LLVM-NEXT:       Owner: Android
+# LLVM-NEXT:       Data size: 0x5
+# LLVM-NEXT:       Type: Unknown (0x00001337)
+# LLVM-NEXT:       Description data (
+# LLVM-NEXT:         0000: 01234567 89
+# LLVM-NEXT:       )
+# LLVM-NEXT:     }
+# LLVM-NEXT:   }
+# LLVM-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_DYN
+Sections:
+  - Name: .note.android.unknown
+    Type: SHT_NOTE
+    Notes:
+      - Name: Android
+        Type: 0x1337
+        Desc: 0123456789

llvm/tools/llvm-readobj/ELFDumper.cpp

case ELF::NT_GNU_PROPERTY_TYPE_0:
     for (const std::string &Property : getGNUPropertyList<ELFT>(Desc))
       OS << "    " << Property << "\n";
     break;
   }
   OS << '\n';
   return true;
 }
 
+using AndroidNoteProperties = std::vector<std::pair<StringRef, std::string>>;
+static AndroidNoteProperties getAndroidNoteProperties(uint32_t NoteType,
+                                                      ArrayRef<uint8_t> Desc) {
+  AndroidNoteProperties Props;
+  switch (NoteType) {
+  case ELF::NT_ANDROID_TYPE_MEMTAG:
+    if (Desc.empty()) {
+      Props.emplace_back("Invalid .note.android.memtag", "");
+      return Props;
+    }
+
+    switch (Desc[0] & NT_MEMTAG_LEVEL_MASK) {
+    case NT_MEMTAG_LEVEL_NONE:
+      Props.emplace_back("Tagging Mode", "NONE");
+      break;
+    case NT_MEMTAG_LEVEL_ASYNC:
+      Props.emplace_back("Tagging Mode", "ASYNC");
+      break;
+    case NT_MEMTAG_LEVEL_SYNC:
+      Props.emplace_back("Tagging Mode", "SYNC");
+      break;
+    default:
+      Props.emplace_back(
+          "Tagging Mode",
+          ("Unknown (" + Twine::utohexstr(Desc[0] & NT_MEMTAG_LEVEL_MASK) + ")")
+              .str());
+      break;
+    }
+    Props.emplace_back("Heap",
+                       (Desc[0] & NT_MEMTAG_HEAP) ? "Enabled" : "Disabled");
+    Props.emplace_back("Stack",
+                       (Desc[0] & NT_MEMTAG_STACK) ? "Enabled" : "Disabled");
+    break;
+  default:
+    return Props;
+  }
+  return Props;
+}
+
+static bool printAndroidNote(raw_ostream &OS, uint32_t NoteType,
+                             ArrayRef<uint8_t> Desc) {
+  // Return true if we were able to pretty-print the note, false otherwise.
+  AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc);
+  if (Props.empty())
+    return false;
+  for (const auto &KV : Props)
+    OS << "    " << KV.first << ": " << KV.second << '\n';
+  OS << '\n';
+  return true;
+}
+
 template <typename ELFT>
 static bool printLLVMOMPOFFLOADNote(raw_ostream &OS, uint32_t NoteType,
                                     ArrayRef<uint8_t> Desc) {
   switch (NoteType) {
   default:
     return false;
   case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION:
     OS << "    Version: " << getDescAsStringRef(Desc);
const NoteType LLVMOMPOFFLOADNoteTypes[] = {
     {ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION,
      "NT_LLVM_OPENMP_OFFLOAD_VERSION (image format version)"},
     {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER,
      "NT_LLVM_OPENMP_OFFLOAD_PRODUCER (producing toolchain)"},
     {ELF::NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION,
      "NT_LLVM_OPENMP_OFFLOAD_PRODUCER_VERSION (producing toolchain version)"},
 };
 
+const NoteType AndroidNoteTypes[] = {
+    {ELF::NT_ANDROID_TYPE_IDENT, "NT_ANDROID_TYPE_IDENT"},
+    {ELF::NT_ANDROID_TYPE_KUSER, "NT_ANDROID_TYPE_KUSER"},
+    {ELF::NT_ANDROID_TYPE_MEMTAG,
+     "NT_ANDROID_TYPE_MEMTAG (Android memory tagging information)"},
+};
+
 const NoteType CoreNoteTypes[] = {
     {ELF::NT_PRSTATUS, "NT_PRSTATUS (prstatus structure)"},
     {ELF::NT_FPREGSET, "NT_FPREGSET (floating point registers)"},
     {ELF::NT_PRPSINFO, "NT_PRPSINFO (prpsinfo structure)"},
     {ELF::NT_TASKSTRUCT, "NT_TASKSTRUCT (task structure)"},
     {ELF::NT_AUXV, "NT_AUXV (auxiliary vector)"},
     {ELF::NT_PSTATUS, "NT_PSTATUS (pstatus structure)"},
     {ELF::NT_FPREGS, "NT_FPREGS (floating point registers)"},
if (ELFType == ELF::ET_CORE && Name.startswith("OpenBSD")) {
     return FindNote(CoreNoteTypes);
   }
   if (Name == "AMD")
     return FindNote(AMDNoteTypes);
   if (Name == "AMDGPU")
     return FindNote(AMDGPUNoteTypes);
   if (Name == "LLVMOMPOFFLOAD")
     return FindNote(LLVMOMPOFFLOADNoteTypes);
+  if (Name == "Android")
+    return FindNote(AndroidNoteTypes);
 
   if (ELFType == ELF::ET_CORE)
     return FindNote(CoreNoteTypes);
   return FindNote(GenericNoteTypes);
 }
 
 template <class ELFT>
 static void printNotesHelper(
if (Name == "GNU") {
                                     sizeof(Elf_Addr));
         if (Expected<CoreNote> NoteOrErr = readCoreNote(DescExtractor)) {
           printCoreNote<ELFT>(OS, *NoteOrErr);
           return Error::success();
         } else {
           return NoteOrErr.takeError();
         }
       }
+    } else if (Name == "Android") {
+      if (printAndroidNote(OS, Type, Descriptor))
+        return Error::success();
     }
     if (!Descriptor.empty()) {
       OS << "   description data:";
       for (uint8_t B : Descriptor)
         OS << " " << format("%02x", B);
       OS << '\n';
     }
     return Error::success();
case ELF::NT_GNU_PROPERTY_TYPE_0:
     ListScope D(W, "Property");
     for (const std::string &Property : getGNUPropertyList<ELFT>(Desc))
       W.printString(Property);
     break;
   }
   return true;
 }
 
+static bool printAndroidNoteLLVMStyle(uint32_t NoteType, ArrayRef<uint8_t> Desc,
+                                      ScopedPrinter &W) {
+  // Return true if we were able to pretty-print the note, false otherwise.
+  AndroidNoteProperties Props = getAndroidNoteProperties(NoteType, Desc);
+  if (Props.empty())
+    return false;
+  for (const auto &KV : Props)
+    W.printString(KV.first, KV.second);
+  return true;
+}
+
 template <typename ELFT>
 static bool printLLVMOMPOFFLOADNoteLLVMStyle(uint32_t NoteType,
                                              ArrayRef<uint8_t> Desc,
                                              ScopedPrinter &W) {
   switch (NoteType) {
   default:
     return false;
   case ELF::NT_LLVM_OPENMP_OFFLOAD_VERSION:
if (Name == "GNU") {
                                     sizeof(Elf_Addr));
         if (Expected<CoreNote> N = readCoreNote(DescExtractor)) {
           printCoreNoteLLVMStyle(*N, W);
           return Error::success();
         } else {
           return N.takeError();
         }
       }
+    } else if (Name == "Android") {
+      if (printAndroidNoteLLVMStyle(Type, Descriptor, W))
+        return Error::success();
     }
     if (!Descriptor.empty()) {
       W.printBinaryBlock("Description data", Descriptor);
     }
     return Error::success();
   };
 
   printNotesHelper(*this, StartNotes, ProcessNote, EndNotes);