Support hint <imm>, and fix hint disassembly.

This allows users to use custom hints without resorting to an undefined
static_cast.

Also, fix disassembly of hints:
  - Add several named hints to the disassembler, so they can be properly
    disassembled.
  - Properly disassemble unnamed hints.

Change-Id: Ia8b4d07a5bff08346faebd5b2f495d047d7037c0

5 files changed, 75 insertions, 2 deletions

diff --git a/src/aarch64/assembler-aarch64.cc b/src/aarch64/assembler-aarch64.cc
index fe743b6d..4617fbac 100644
--- a/src/aarch64/assembler-aarch64.cc
+++ b/src/aarch64/assembler-aarch64.cc
@@ -1572,7 +1572,13 @@ void Assembler::ic(InstructionCacheOp op, const Register& rt) {
 }
 
 
-void Assembler::hint(SystemHint code) { Emit(HINT | ImmHint(code) | Rt(xzr)); }
+void Assembler::hint(SystemHint code) { hint(static_cast<int>(code)); }
+
+
+void Assembler::hint(int imm7) {
+  VIXL_ASSERT(IsUint7(imm7));
+  Emit(HINT | ImmHint(imm7) | Rt(xzr));
+}
 
 
 // NEON structure loads and stores.
diff --git a/src/aarch64/assembler-aarch64.h b/src/aarch64/assembler-aarch64.h
index 9ccd2c56..54256fb4 100644
--- a/src/aarch64/assembler-aarch64.h
+++ b/src/aarch64/assembler-aarch64.h
@@ -1336,9 +1336,12 @@ class Assembler : public vixl::internal::AssemblerBase {
   // System instruction cache operation.
   void ic(InstructionCacheOp op, const Register& rt);
 
-  // System hint.
+  // System hint (named type).
   void hint(SystemHint code);
 
+  // System hint (numbered type).
+  void hint(int imm7);
+
   // Clear exclusive monitor.
   void clrex(int imm4 = 0xf);
 
diff --git a/src/aarch64/disasm-aarch64.cc b/src/aarch64/disasm-aarch64.cc
index 42235d4d..100b23e8 100644
--- a/src/aarch64/disasm-aarch64.cc
+++ b/src/aarch64/disasm-aarch64.cc
@@ -1736,11 +1736,42 @@ void Disassembler::VisitSystem(const Instruction *instr) {
         mnemonic = "nop";
         break;
       }
+      case YIELD: {
+        form = NULL;
+        mnemonic = "yield";
+        break;
+      }
+      case WFE: {
+        form = NULL;
+        mnemonic = "wfe";
+        break;
+      }
+      case WFI: {
+        form = NULL;
+        mnemonic = "wfi";
+        break;
+      }
+      case SEV: {
+        form = NULL;
+        mnemonic = "sev";
+        break;
+      }
+      case SEVL: {
+        form = NULL;
+        mnemonic = "sevl";
+        break;
+      }
       case CSDB: {
         form = NULL;
         mnemonic = "csdb";
         break;
       }
+      default: {
+        // Fall back to 'hint #<imm7>'.
+        form = "'IH";
+        mnemonic = "hint";
+        break;
+      }
     }
   } else if (instr->Mask(MemBarrierFMask) == MemBarrierFixed) {
     switch (instr->Mask(MemBarrierMask)) {
@@ -4560,6 +4591,10 @@ int Disassembler::SubstituteImmediateField(const Instruction *instr,
         }
       }
     }
+    case 'H': {  // IH - ImmHint
+      AppendToOutput("#%" PRId32, instr->GetImmHint());
+      return 2;
+    }
     case 'T': {  // ITri - Immediate Triangular Encoded.
       AppendToOutput("#0x%" PRIx64, instr->GetImmLogical());
       return 4;
diff --git a/src/aarch64/macro-assembler-aarch64.h b/src/aarch64/macro-assembler-aarch64.h
index 47929c38..0a4d02ec 100644
--- a/src/aarch64/macro-assembler-aarch64.h
+++ b/src/aarch64/macro-assembler-aarch64.h
@@ -1454,6 +1454,11 @@ class MacroAssembler : public Assembler, public MacroAssemblerInterface {
     SingleEmissionCheckScope guard(this);
     hint(code);
   }
+  void Hint(int imm7) {
+    VIXL_ASSERT(allow_macro_instructions_);
+    SingleEmissionCheckScope guard(this);
+    hint(imm7);
+  }
   void Hlt(int code) {
     VIXL_ASSERT(allow_macro_instructions_);
     SingleEmissionCheckScope guard(this);
diff --git a/test/aarch64/test-disasm-aarch64.cc b/test/aarch64/test-disasm-aarch64.cc
index 426319ff..b494780c 100644
--- a/test/aarch64/test-disasm-aarch64.cc
+++ b/test/aarch64/test-disasm-aarch64.cc
@@ -7018,5 +7018,29 @@ TEST(address_map) {
   CLEANUP();
 }
 
+TEST(hint) {
+  SETUP();
+
+  // Test that we properly disassemble named and unnamed hints.
+  COMPARE(hint(NOP), "nop");
+  COMPARE(hint(YIELD), "yield");
+  COMPARE(hint(WFE), "wfe");
+  COMPARE(hint(WFI), "wfi");
+  COMPARE(hint(SEV), "sev");
+  COMPARE(hint(SEVL), "sevl");
+  COMPARE(hint(6), "hint #6");
+  COMPARE(hint(CSDB), "csdb");
+  COMPARE(hint(42), "hint #42");
+  COMPARE(hint(127), "hint #127");
+
+  // The MacroAssembler should simply pass through to the Assembler.
+  COMPARE_MACRO(Hint(NOP), "nop");
+  COMPARE_MACRO(Hint(CSDB), "csdb");
+  COMPARE_MACRO(Hint(42), "hint #42");
+  COMPARE_MACRO(Hint(127), "hint #127");
+
+  CLEANUP();
+}
+
 }  // namespace aarch64
 }  // namespace vixl