Index: llvm/lib/MC/MCParser/AsmParser.cpp
===================================================================
--- llvm/lib/MC/MCParser/AsmParser.cpp
+++ llvm/lib/MC/MCParser/AsmParser.cpp
@@ -199,7 +199,7 @@
   }
 
   void addAliasForDirective(StringRef Directive, StringRef Alias) override {
-    DirectiveKindMap[Directive] = DirectiveKindMap[Alias];
+    DirectiveKindMap[Directive.lower()] = DirectiveKindMap[Alias.lower()];
   }
 
   /// @name MCAsmParser Interface
@@ -681,6 +681,7 @@
   bool parseDirectiveAddrsig();
   bool parseDirectiveAddrsigSym();
 
+  void addDirective(StringRef directive, DirectiveKind kind);
   void initializeDirectiveKindMap();
   void initializeCVDefRangeTypeMap();
 };
@@ -1750,7 +1751,7 @@
   // have to do this so that .endif isn't skipped in a ".if 0" block for
   // example.
   StringMap<DirectiveKind>::const_iterator DirKindIt =
-      DirectiveKindMap.find(IDVal);
+      DirectiveKindMap.find(IDVal.lower());
   DirectiveKind DirKind = (DirKindIt == DirectiveKindMap.end())
 
                               ? DK_NO_DIRECTIVE
@@ -5319,166 +5320,170 @@
   return false;
 }
 
+void AsmParser::addDirective(StringRef directive, DirectiveKind kind) {
+  DirectiveKindMap[directive.lower()] = kind;
+}
+
 void AsmParser::initializeDirectiveKindMap() {
-  DirectiveKindMap[".set"] = DK_SET;
-  DirectiveKindMap[".equ"] = DK_EQU;
-  DirectiveKindMap[".equiv"] = DK_EQUIV;
-  DirectiveKindMap[".ascii"] = DK_ASCII;
-  DirectiveKindMap[".asciz"] = DK_ASCIZ;
-  DirectiveKindMap[".string"] = DK_STRING;
-  DirectiveKindMap[".byte"] = DK_BYTE;
-  DirectiveKindMap[".short"] = DK_SHORT;
-  DirectiveKindMap[".value"] = DK_VALUE;
-  DirectiveKindMap[".2byte"] = DK_2BYTE;
-  DirectiveKindMap[".long"] = DK_LONG;
-  DirectiveKindMap[".int"] = DK_INT;
-  DirectiveKindMap[".4byte"] = DK_4BYTE;
-  DirectiveKindMap[".quad"] = DK_QUAD;
-  DirectiveKindMap[".8byte"] = DK_8BYTE;
-  DirectiveKindMap[".octa"] = DK_OCTA;
-  DirectiveKindMap[".single"] = DK_SINGLE;
-  DirectiveKindMap[".float"] = DK_FLOAT;
-  DirectiveKindMap[".double"] = DK_DOUBLE;
-  DirectiveKindMap[".align"] = DK_ALIGN;
-  DirectiveKindMap[".align32"] = DK_ALIGN32;
-  DirectiveKindMap[".balign"] = DK_BALIGN;
-  DirectiveKindMap[".balignw"] = DK_BALIGNW;
-  DirectiveKindMap[".balignl"] = DK_BALIGNL;
-  DirectiveKindMap[".p2align"] = DK_P2ALIGN;
-  DirectiveKindMap[".p2alignw"] = DK_P2ALIGNW;
-  DirectiveKindMap[".p2alignl"] = DK_P2ALIGNL;
-  DirectiveKindMap[".org"] = DK_ORG;
-  DirectiveKindMap[".fill"] = DK_FILL;
-  DirectiveKindMap[".zero"] = DK_ZERO;
-  DirectiveKindMap[".extern"] = DK_EXTERN;
-  DirectiveKindMap[".globl"] = DK_GLOBL;
-  DirectiveKindMap[".global"] = DK_GLOBAL;
-  DirectiveKindMap[".lazy_reference"] = DK_LAZY_REFERENCE;
-  DirectiveKindMap[".no_dead_strip"] = DK_NO_DEAD_STRIP;
-  DirectiveKindMap[".symbol_resolver"] = DK_SYMBOL_RESOLVER;
-  DirectiveKindMap[".private_extern"] = DK_PRIVATE_EXTERN;
-  DirectiveKindMap[".reference"] = DK_REFERENCE;
-  DirectiveKindMap[".weak_definition"] = DK_WEAK_DEFINITION;
-  DirectiveKindMap[".weak_reference"] = DK_WEAK_REFERENCE;
-  DirectiveKindMap[".weak_def_can_be_hidden"] = DK_WEAK_DEF_CAN_BE_HIDDEN;
-  DirectiveKindMap[".cold"] = DK_COLD;
-  DirectiveKindMap[".comm"] = DK_COMM;
-  DirectiveKindMap[".common"] = DK_COMMON;
-  DirectiveKindMap[".lcomm"] = DK_LCOMM;
-  DirectiveKindMap[".abort"] = DK_ABORT;
-  DirectiveKindMap[".include"] = DK_INCLUDE;
-  DirectiveKindMap[".incbin"] = DK_INCBIN;
-  DirectiveKindMap[".code16"] = DK_CODE16;
-  DirectiveKindMap[".code16gcc"] = DK_CODE16GCC;
-  DirectiveKindMap[".rept"] = DK_REPT;
-  DirectiveKindMap[".rep"] = DK_REPT;
-  DirectiveKindMap[".irp"] = DK_IRP;
-  DirectiveKindMap[".irpc"] = DK_IRPC;
-  DirectiveKindMap[".endr"] = DK_ENDR;
-  DirectiveKindMap[".bundle_align_mode"] = DK_BUNDLE_ALIGN_MODE;
-  DirectiveKindMap[".bundle_lock"] = DK_BUNDLE_LOCK;
-  DirectiveKindMap[".bundle_unlock"] = DK_BUNDLE_UNLOCK;
-  DirectiveKindMap[".if"] = DK_IF;
-  DirectiveKindMap[".ifeq"] = DK_IFEQ;
-  DirectiveKindMap[".ifge"] = DK_IFGE;
-  DirectiveKindMap[".ifgt"] = DK_IFGT;
-  DirectiveKindMap[".ifle"] = DK_IFLE;
-  DirectiveKindMap[".iflt"] = DK_IFLT;
-  DirectiveKindMap[".ifne"] = DK_IFNE;
-  DirectiveKindMap[".ifb"] = DK_IFB;
-  DirectiveKindMap[".ifnb"] = DK_IFNB;
-  DirectiveKindMap[".ifc"] = DK_IFC;
-  DirectiveKindMap[".ifeqs"] = DK_IFEQS;
-  DirectiveKindMap[".ifnc"] = DK_IFNC;
-  DirectiveKindMap[".ifnes"] = DK_IFNES;
-  DirectiveKindMap[".ifdef"] = DK_IFDEF;
-  DirectiveKindMap[".ifndef"] = DK_IFNDEF;
-  DirectiveKindMap[".ifnotdef"] = DK_IFNOTDEF;
-  DirectiveKindMap[".elseif"] = DK_ELSEIF;
-  DirectiveKindMap[".else"] = DK_ELSE;
-  DirectiveKindMap[".end"] = DK_END;
-  DirectiveKindMap[".endif"] = DK_ENDIF;
-  DirectiveKindMap[".skip"] = DK_SKIP;
-  DirectiveKindMap[".space"] = DK_SPACE;
-  DirectiveKindMap[".file"] = DK_FILE;
-  DirectiveKindMap[".line"] = DK_LINE;
-  DirectiveKindMap[".loc"] = DK_LOC;
-  DirectiveKindMap[".stabs"] = DK_STABS;
-  DirectiveKindMap[".cv_file"] = DK_CV_FILE;
-  DirectiveKindMap[".cv_func_id"] = DK_CV_FUNC_ID;
-  DirectiveKindMap[".cv_loc"] = DK_CV_LOC;
-  DirectiveKindMap[".cv_linetable"] = DK_CV_LINETABLE;
-  DirectiveKindMap[".cv_inline_linetable"] = DK_CV_INLINE_LINETABLE;
-  DirectiveKindMap[".cv_inline_site_id"] = DK_CV_INLINE_SITE_ID;
-  DirectiveKindMap[".cv_def_range"] = DK_CV_DEF_RANGE;
-  DirectiveKindMap[".cv_string"] = DK_CV_STRING;
-  DirectiveKindMap[".cv_stringtable"] = DK_CV_STRINGTABLE;
-  DirectiveKindMap[".cv_filechecksums"] = DK_CV_FILECHECKSUMS;
-  DirectiveKindMap[".cv_filechecksumoffset"] = DK_CV_FILECHECKSUM_OFFSET;
-  DirectiveKindMap[".cv_fpo_data"] = DK_CV_FPO_DATA;
-  DirectiveKindMap[".sleb128"] = DK_SLEB128;
-  DirectiveKindMap[".uleb128"] = DK_ULEB128;
-  DirectiveKindMap[".cfi_sections"] = DK_CFI_SECTIONS;
-  DirectiveKindMap[".cfi_startproc"] = DK_CFI_STARTPROC;
-  DirectiveKindMap[".cfi_endproc"] = DK_CFI_ENDPROC;
-  DirectiveKindMap[".cfi_def_cfa"] = DK_CFI_DEF_CFA;
-  DirectiveKindMap[".cfi_def_cfa_offset"] = DK_CFI_DEF_CFA_OFFSET;
-  DirectiveKindMap[".cfi_adjust_cfa_offset"] = DK_CFI_ADJUST_CFA_OFFSET;
-  DirectiveKindMap[".cfi_def_cfa_register"] = DK_CFI_DEF_CFA_REGISTER;
-  DirectiveKindMap[".cfi_offset"] = DK_CFI_OFFSET;
-  DirectiveKindMap[".cfi_rel_offset"] = DK_CFI_REL_OFFSET;
-  DirectiveKindMap[".cfi_personality"] = DK_CFI_PERSONALITY;
-  DirectiveKindMap[".cfi_lsda"] = DK_CFI_LSDA;
-  DirectiveKindMap[".cfi_remember_state"] = DK_CFI_REMEMBER_STATE;
-  DirectiveKindMap[".cfi_restore_state"] = DK_CFI_RESTORE_STATE;
-  DirectiveKindMap[".cfi_same_value"] = DK_CFI_SAME_VALUE;
-  DirectiveKindMap[".cfi_restore"] = DK_CFI_RESTORE;
-  DirectiveKindMap[".cfi_escape"] = DK_CFI_ESCAPE;
-  DirectiveKindMap[".cfi_return_column"] = DK_CFI_RETURN_COLUMN;
-  DirectiveKindMap[".cfi_signal_frame"] = DK_CFI_SIGNAL_FRAME;
-  DirectiveKindMap[".cfi_undefined"] = DK_CFI_UNDEFINED;
-  DirectiveKindMap[".cfi_register"] = DK_CFI_REGISTER;
-  DirectiveKindMap[".cfi_window_save"] = DK_CFI_WINDOW_SAVE;
-  DirectiveKindMap[".cfi_b_key_frame"] = DK_CFI_B_KEY_FRAME;
-  DirectiveKindMap[".macros_on"] = DK_MACROS_ON;
-  DirectiveKindMap[".macros_off"] = DK_MACROS_OFF;
-  DirectiveKindMap[".macro"] = DK_MACRO;
-  DirectiveKindMap[".exitm"] = DK_EXITM;
-  DirectiveKindMap[".endm"] = DK_ENDM;
-  DirectiveKindMap[".endmacro"] = DK_ENDMACRO;
-  DirectiveKindMap[".purgem"] = DK_PURGEM;
-  DirectiveKindMap[".err"] = DK_ERR;
-  DirectiveKindMap[".error"] = DK_ERROR;
-  DirectiveKindMap[".warning"] = DK_WARNING;
-  DirectiveKindMap[".altmacro"] = DK_ALTMACRO;
-  DirectiveKindMap[".noaltmacro"] = DK_NOALTMACRO;
-  DirectiveKindMap[".reloc"] = DK_RELOC;
-  DirectiveKindMap[".dc"] = DK_DC;
-  DirectiveKindMap[".dc.a"] = DK_DC_A;
-  DirectiveKindMap[".dc.b"] = DK_DC_B;
-  DirectiveKindMap[".dc.d"] = DK_DC_D;
-  DirectiveKindMap[".dc.l"] = DK_DC_L;
-  DirectiveKindMap[".dc.s"] = DK_DC_S;
-  DirectiveKindMap[".dc.w"] = DK_DC_W;
-  DirectiveKindMap[".dc.x"] = DK_DC_X;
-  DirectiveKindMap[".dcb"] = DK_DCB;
-  DirectiveKindMap[".dcb.b"] = DK_DCB_B;
-  DirectiveKindMap[".dcb.d"] = DK_DCB_D;
-  DirectiveKindMap[".dcb.l"] = DK_DCB_L;
-  DirectiveKindMap[".dcb.s"] = DK_DCB_S;
-  DirectiveKindMap[".dcb.w"] = DK_DCB_W;
-  DirectiveKindMap[".dcb.x"] = DK_DCB_X;
-  DirectiveKindMap[".ds"] = DK_DS;
-  DirectiveKindMap[".ds.b"] = DK_DS_B;
-  DirectiveKindMap[".ds.d"] = DK_DS_D;
-  DirectiveKindMap[".ds.l"] = DK_DS_L;
-  DirectiveKindMap[".ds.p"] = DK_DS_P;
-  DirectiveKindMap[".ds.s"] = DK_DS_S;
-  DirectiveKindMap[".ds.w"] = DK_DS_W;
-  DirectiveKindMap[".ds.x"] = DK_DS_X;
-  DirectiveKindMap[".print"] = DK_PRINT;
-  DirectiveKindMap[".addrsig"] = DK_ADDRSIG;
-  DirectiveKindMap[".addrsig_sym"] = DK_ADDRSIG_SYM;
+  addDirective(".set", DK_SET);
+  addDirective(".equ", DK_EQU);
+  addDirective(".equiv", DK_EQUIV);
+  addDirective(".ascii", DK_ASCII);
+  addDirective(".asciz", DK_ASCIZ);
+  addDirective(".string", DK_STRING);
+  addDirective(".byte", DK_BYTE);
+  addDirective(".short", DK_SHORT);
+  addDirective(".value", DK_VALUE);
+  addDirective(".2byte", DK_2BYTE);
+  addDirective(".long", DK_LONG);
+  addDirective(".int", DK_INT);
+  addDirective(".4byte", DK_4BYTE);
+  addDirective(".quad", DK_QUAD);
+  addDirective(".8byte", DK_8BYTE);
+  addDirective(".octa", DK_OCTA);
+  addDirective(".single", DK_SINGLE);
+  addDirective(".float", DK_FLOAT);
+  addDirective(".double", DK_DOUBLE);
+  addDirective(".align", DK_ALIGN);
+  addDirective(".align32", DK_ALIGN32);
+  addDirective(".balign", DK_BALIGN);
+  addDirective(".balignw", DK_BALIGNW);
+  addDirective(".balignl", DK_BALIGNL);
+  addDirective(".p2align",  DK_P2ALIGN);
+  addDirective(".p2alignw", DK_P2ALIGNW);
+  addDirective(".p2alignl", DK_P2ALIGNL);
+  addDirective(".org", DK_ORG);
+  addDirective(".fill", DK_FILL);
+  addDirective(".zero", DK_ZERO);
+  addDirective(".extern", DK_EXTERN);
+  addDirective(".globl", DK_GLOBL);
+  addDirective(".global", DK_GLOBAL);
+  addDirective(".lazy_reference", DK_LAZY_REFERENCE);
+  addDirective(".no_dead_strip", DK_NO_DEAD_STRIP);
+  addDirective(".symbol_resolver", DK_SYMBOL_RESOLVER);
+  addDirective(".private_extern", DK_PRIVATE_EXTERN);
+  addDirective(".reference", DK_REFERENCE);
+  addDirective(".weak_definition", DK_WEAK_DEFINITION);
+  addDirective(".weak_reference", DK_WEAK_REFERENCE);
+  addDirective(".weak_def_can_be_hidden", DK_WEAK_DEF_CAN_BE_HIDDEN);
+  addDirective(".cold", DK_COLD);
+  addDirective(".comm", DK_COMM);
+  addDirective(".common", DK_COMMON);
+  addDirective(".lcomm", DK_LCOMM);
+  addDirective(".abort", DK_ABORT);
+  addDirective(".include", DK_INCLUDE);
+  addDirective(".incbin", DK_INCBIN);
+  addDirective(".code16", DK_CODE16);
+  addDirective(".code16gcc", DK_CODE16GCC);
+  addDirective(".rept", DK_REPT);
+  addDirective(".rep", DK_REPT);
+  addDirective(".irp", DK_IRP);
+  addDirective(".irpc", DK_IRPC);
+  addDirective(".endr", DK_ENDR);
+  addDirective(".bundle_align_mode", DK_BUNDLE_ALIGN_MODE);
+  addDirective(".bundle_lock", DK_BUNDLE_LOCK);
+  addDirective(".bundle_unlock", DK_BUNDLE_UNLOCK);
+  addDirective(".if", DK_IF);
+  addDirective(".ifeq", DK_IFEQ);
+  addDirective(".ifge", DK_IFGE);
+  addDirective(".ifgt", DK_IFGT);
+  addDirective(".ifle", DK_IFLE);
+  addDirective(".iflt", DK_IFLT);
+  addDirective(".ifne", DK_IFNE);
+  addDirective(".ifb", DK_IFB);
+  addDirective(".ifnb",  DK_IFNB);
+  addDirective(".ifc", DK_IFC);
+  addDirective(".ifeqs", DK_IFEQS);
+  addDirective(".ifnc", DK_IFNC);
+  addDirective(".ifnes", DK_IFNES);
+  addDirective(".ifdef", DK_IFDEF);
+  addDirective(".ifndef", DK_IFNDEF);
+  addDirective(".ifnotdef", DK_IFNOTDEF);
+  addDirective(".elseif", DK_ELSEIF);
+  addDirective(".else", DK_ELSE);
+  addDirective(".end", DK_END);
+  addDirective(".endif", DK_ENDIF);
+  addDirective(".skip", DK_SKIP);
+  addDirective(".space", DK_SPACE);
+  addDirective(".file", DK_FILE);
+  addDirective(".line", DK_LINE);
+  addDirective(".loc", DK_LOC);
+  addDirective(".stabs", DK_STABS);
+  addDirective(".cv_file", DK_CV_FILE);
+  addDirective(".cv_func_id", DK_CV_FUNC_ID);
+  addDirective(".cv_loc", DK_CV_LOC);
+  addDirective(".cv_linetable", DK_CV_LINETABLE);
+  addDirective(".cv_inline_linetable", DK_CV_INLINE_LINETABLE);
+  addDirective(".cv_inline_site_id", DK_CV_INLINE_SITE_ID);
+  addDirective(".cv_def_range", DK_CV_DEF_RANGE);
+  addDirective(".cv_string", DK_CV_STRING);
+  addDirective(".cv_stringtable", DK_CV_STRINGTABLE);
+  addDirective(".cv_filechecksums", DK_CV_FILECHECKSUMS);
+  addDirective(".cv_filechecksumoffset", DK_CV_FILECHECKSUM_OFFSET);
+  addDirective(".cv_fpo_data", DK_CV_FPO_DATA);
+  addDirective(".sleb128", DK_SLEB128);
+  addDirective(".uleb128", DK_ULEB128);
+  addDirective(".cfi_sections", DK_CFI_SECTIONS);
+  addDirective(".cfi_startproc", DK_CFI_STARTPROC);
+  addDirective(".cfi_endproc", DK_CFI_ENDPROC);
+  addDirective(".cfi_def_cfa", DK_CFI_DEF_CFA);
+  addDirective(".cfi_def_cfa_offset", DK_CFI_DEF_CFA_OFFSET);
+  addDirective(".cfi_adjust_cfa_offset", DK_CFI_ADJUST_CFA_OFFSET);
+  addDirective(".cfi_def_cfa_register", DK_CFI_DEF_CFA_REGISTER);
+  addDirective(".cfi_offset", DK_CFI_OFFSET);
+  addDirective(".cfi_rel_offset", DK_CFI_REL_OFFSET);
+  addDirective(".cfi_personality", DK_CFI_PERSONALITY);
+  addDirective(".cfi_lsda", DK_CFI_LSDA);
+  addDirective(".cfi_remember_state", DK_CFI_REMEMBER_STATE);
+  addDirective(".cfi_restore_state", DK_CFI_RESTORE_STATE);
+  addDirective(".cfi_same_value", DK_CFI_SAME_VALUE);
+  addDirective(".cfi_restore", DK_CFI_RESTORE);
+  addDirective(".cfi_escape", DK_CFI_ESCAPE);
+  addDirective(".cfi_return_column", DK_CFI_RETURN_COLUMN);
+  addDirective(".cfi_signal_frame", DK_CFI_SIGNAL_FRAME);
+  addDirective(".cfi_undefined", DK_CFI_UNDEFINED);
+  addDirective(".cfi_register", DK_CFI_REGISTER);
+  addDirective(".cfi_window_save", DK_CFI_WINDOW_SAVE);
+  addDirective(".cfi_b_key_frame", DK_CFI_B_KEY_FRAME);
+  addDirective(".macros_on", DK_MACROS_ON);
+  addDirective(".macros_off", DK_MACROS_OFF);
+  addDirective(".macro", DK_MACRO);
+  addDirective(".exitm", DK_EXITM);
+  addDirective(".endm", DK_ENDM);
+  addDirective(".endmacro", DK_ENDMACRO);
+  addDirective(".purgem", DK_PURGEM);
+  addDirective(".err", DK_ERR);
+  addDirective(".error", DK_ERROR);
+  addDirective(".warning", DK_WARNING);
+  addDirective(".altmacro", DK_ALTMACRO);
+  addDirective(".noaltmacro", DK_NOALTMACRO);
+  addDirective(".reloc", DK_RELOC);
+  addDirective(".dc", DK_DC);
+  addDirective(".dc.a", DK_DC_A);
+  addDirective(".dc.b", DK_DC_B);
+  addDirective(".dc.d", DK_DC_D);
+  addDirective(".dc.l", DK_DC_L);
+  addDirective(".dc.s", DK_DC_S);
+  addDirective(".dc.w", DK_DC_W);
+  addDirective(".dc.x", DK_DC_X);
+  addDirective(".dcb", DK_DCB);
+  addDirective(".dcb.b", DK_DCB_B);
+  addDirective(".dcb.d", DK_DCB_D);
+  addDirective(".dcb.l", DK_DCB_L);
+  addDirective(".dcb.s", DK_DCB_S);
+  addDirective(".dcb.w", DK_DCB_W);
+  addDirective(".dcb.x", DK_DCB_X);
+  addDirective(".ds", DK_DS);
+  addDirective(".ds.b", DK_DS_B);
+  addDirective(".ds.d", DK_DS_D);
+  addDirective(".ds.l", DK_DS_L);
+  addDirective(".ds.p", DK_DS_P);
+  addDirective(".ds.s", DK_DS_S);
+  addDirective(".ds.w", DK_DS_W);
+  addDirective(".ds.x", DK_DS_X);
+  addDirective(".print", DK_PRINT);
+  addDirective(".addrsig", DK_ADDRSIG);
+  addDirective(".addrsig_sym", DK_ADDRSIG_SYM);
 }
 
 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
Index: llvm/test/MC/AsmParser/directive_case_insensitive.s
===================================================================
--- /dev/null
+++ llvm/test/MC/AsmParser/directive_case_insensitive.s
@@ -0,0 +1,17 @@
+# RUN: llvm-mc -triple aarch64 %s | FileCheck %s
+
+        .data
+# CHECK: .byte 65
+        .ascii "A"
+# CHECK: .byte 66
+        .ASCII "B"
+# CHECK: .byte 67
+        .aScIi "C"
+
+# Note: using hword because it is an alias
+# CHECK: .hword 4660
+        .hword 0x1234
+# CHECK: .hword 4661
+        .HWORD 0x1235
+# CHECK: .hword 4662
+        .hWoRd 0x1236