Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "def", "DD", ":", "RegisterClass", "<", "<STR_LIT>", ",", "[", "untyped", "]", ",", "<NUM_LIT>", ",", "(", "add", "DSeqPairs", ")", ">", "{", "let", "Size", "=", "<NUM_LIT>", ";" ]

[ "_", "_", "Y", ",", "_", "CMP_NLE_US", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_cmppd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "X", ",", "(", "_", "_", "v8df", ")" ]

[ "<STR_LIT>", ")", ";" ]

[ "void", "addRegVSFRCOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "set", "+", "i", ")", ")", ",", "<NUM_LIT>", ",", "set", "+", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "nsets", "=", "nunits", "/", "<NUM_LIT>", ";", "int", "set", "=", "<NUM_LIT>", ";", "int", "i", ",", "j", ";", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "<", "nsets", ";", "j", "++", ",", "set", "=", "<NUM_LIT>", "*", "j", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "(", "INTVAL", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "i", ")", ")", "!=", "(", "INTVAL", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "set", "+", "i", ")", ")", "-", "set", ")" ]

[ "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "if", "(", "!", "cast", "<", "VectorType", ">", "(", "BO", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")" ]

[ "}" ]

[ "static", "void", "arm_asm_init_sections", "(", "void", ")", "{", "exception_section", "=", "get_unnamed_section", "(", "<NUM_LIT>", ",", "output_section_asm_op", ",", "<STR_LIT>", "\\t.handlerdata", "<STR_LIT>", ")", ";", "if", "(", "target_pure_code", ")", "text_section", "->", "unnamed", ".", "data", "=", "<STR_LIT>", "\\t.section .text,\\\"0x20000006\\\",%progbits", "<STR_LIT>", ";" ]

[ "void", "Z80MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MC", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented", "<STR_LIT>", ")", ";", "}" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "_", "v8hi", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_cvtepu8_epi16", "(", "_", "_", "m128i", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovzxbw128_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "A", ",", "(", "_" ]

[ "=", "<NUM_LIT>", ";" ]

[ "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "<STR_LIT>", "section", "<STR_LIT>", ")", ",", "build_tree_list", "(", "NULL", ",", "build_string", "(", "strlen", "(", "dsec", ")", ",", "dsec", ")", ")", ",", "*", "attributes", ")", ";", "TREE_READONLY", "(", "node", ")" ]

[ "]", ")" ]

[ "UNSPEC_FMULS", "UNSPEC_FMULSU", "UNSPEC_COPYSIGN", "UNSPEC_IDENTITY", "UNSPEC_INSERT_BITS", "UNSPEC_JMP_EPILOG", "UNSPEC_JMP_EPILOG24", "UNSPEC_JMP_PROLOG", "UNSPEC_XCHG" ]

[ "ival", "=", "(", "(", "ival", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";" ]

[ "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "<STR_LIT>", ":tls_load:", "<STR_LIT>", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "==", "UNSPEC_TLSGD", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "<STR_LIT>", ":tls_gdcall:", "<STR_LIT>", ")", ";", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "<NUM_LIT>", ")", "==", "UNSPEC_TLSLDM", ")", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "<STR_LIT>", ":tls_ldcall:", "<STR_LIT>", ")", ";", "const", "char", "*", "name", "=", "get_some_local_dynamic_name", "(", ")", ";", "gcc_assert", "(", "name", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "}", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid reference for 'J' output modifier", "<STR_LIT>", ")", ";", "return", ";", "case", "'", "G", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%u", "<STR_LIT>", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ")", ";", "return", ";", "case", "'", "O", "'", ":", "{", "struct", "s390_address", "ad", ";", "int", "ret", ";", "ret", "=", "s390_decompose_address", "(", "MEM_P", "(", "x", ")", "?", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ":", "x", ",", "&", "ad", ")", ";", "if", "(", "!", "ret", "||", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "||", "ad", ".", "indx", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid address for 'O' output modifier", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "ad", ".", "disp", ")", "output_addr_const", "(", "file", ",", "ad", ".", "disp", ")", ";", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "}", "return", ";", "case", "'", "R", "'", ":", "{", "struct", "s390_address", "ad", ";", "int", "ret", ";", "ret", "=", "s390_decompose_address", "(", "MEM_P", "(", "x", ")", "?", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ":", "x", ",", "&", "ad", ")", ";", "if", "(", "!", "ret", "||", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "||", "ad", ".", "indx", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid address for 'R' output modifier", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "ad", ".", "base", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "}", "return", ";", "case", "'", "S", "'", ":", "{", "struct", "s390_address", "ad", ";", "int", "ret", ";", "if", "(", "!", "MEM_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "memory reference expected for ", "<STR_LIT>", "<STR_LIT>", "'S' output modifier", "<STR_LIT>", ")", ";", "return", ";", "}", "ret", "=", "s390_decompose_address", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "&", "ad", ")", ";", "if", "(", "!", "ret", "||", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "||", "ad", ".", "indx", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid address for 'S' output modifier", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "ad", ".", "disp", ")", "output_addr_const", "(", "file", ",", "ad", ".", "disp", ")", ";", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "if", "(", "ad", ".", "base", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "}", "return", ";", "case", "'", "N", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "x", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "x", ")", ",", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "x", "=", "change_address", "(", "x", ",", "VOIDmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "register or memory expression expected ", "<STR_LIT>", "<STR_LIT>", "for 'N' output modifier", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "M", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "x", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "x", ")", ",", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "x", "=", "change_address", "(", "x", ",", "VOIDmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "register or memory expression expected ", "<STR_LIT>", "<STR_LIT>", "for 'M' output modifier", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "Y", "'", ":", "print_addrstyle_operand", "(", "file", ",", "x", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "if", "(", "code", "==", "'", "v", "'", "||", "VECTOR_NOFP_REG_P", "(", "x", ")", "||", "(", "FP_REG_P", "(", "x", ")", "&&", "VECTOR_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "||", "(", "VECTOR_REG_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "/", "s390_class_max_nregs", "(", "FP_REGS", ",", "GET_MODE", "(", "x", ")", ")", ")", ">", "<NUM_LIT>", ")", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%%v%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", "+", "<NUM_LIT>", ")", ";", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "CONST", ":", "case", "CODE_LABEL", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "case", "CONST_INT", ":", "ival", "=", "INTVAL", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "<NUM_LIT>", ":", "break", ";", "case", "'", "b", "'", ":", "ival", "&=", "<NUM_LIT>", ";", "break", ";", "case", "'", "c", "'", ":", "ival", "=", "(", "(", "ival", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "break", ";", "case", "'", "x", "'", ":", "ival", "&=", "<NUM_LIT>", ";", "break", ";", "case", "'", "h", "'", ":" ]

[ "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>" ]

[ "}" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "Unpredictable", "=", "<NUM_LIT>", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "Unpredictable", ";", "let", "Namespace", "=", "<STR_LIT>", ";", "Format", "F", "=", "f", ";", "bits", "<", "<NUM_LIT>", ">", "Form", "=", "F", ".", "Value", ";", "let", "Pattern", "=", "[", "]", ";", "let", "Constraints", "=", "cstr", ";" ]

[ ")", ";" ]

[ "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "Register", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "Register", "FramePtrReg", "=", "FuncInfo", "->", "getFrameOffsetReg", "(", ")", ";", "LivePhysRegs", "LiveRegs", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "HasFP", "=", "false", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint32_t", "RoundedSize", "=", "NumBytes", ";", "Register", "ScratchExecCopy", ";", "if", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", ".", "addReg", "(", "FramePtrReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "MBB", ".", "addLiveIn", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", ";", "}", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "if", "(", "!", "ScratchExecCopy", ")", "{", "if", "(", "LiveRegs", ".", "empty", "(", ")", ")", "{", "LiveRegs", ".", "init", "(", "TRI", ")", ";", "LiveRegs", ".", "addLiveIns", "(", "MBB", ")", ";", "if", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", "LiveRegs", ".", "removeReg", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", ";", "}", "ScratchExecCopy", "=", "findScratchNonCalleeSaveRegister", "(", "MRI", ",", "LiveRegs", ",", "*", "TRI", ".", "getWaveMaskRegClass", "(", ")", ")", ";", "assert", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", "!=", "ScratchExecCopy", ")", ";", "const", "unsigned", "OrSaveExec", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ":", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "OrSaveExec", ")", ",", "ScratchExecCopy", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "}", "buildPrologSpill", "(", "LiveRegs", ",", "MBB", ",", "MBBI", ",", "TII", ",", "Reg", ".", "VGPR", ",", "FuncInfo", "->", "getScratchRSrcReg", "(", ")", ",", "StackPtrReg", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ")", ";", "}", "if", "(", "ScratchExecCopy", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "unsigned", "ExecMov", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32", ":", "AMDGPU", "::", "S_MOV_B64", ";", "MCRegister", "Exec", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "EXEC_LO", ":", "AMDGPU", "::", "EXEC", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "ExecMov", ")", ",", "Exec", ")", ".", "addReg", "(", "ScratchExecCopy", ",", "RegState", "::", "Kill", ")", ";", "LiveRegs", ".", "addReg", "(", "ScratchExecCopy", ")", ";", "}", "if", "(", "FuncInfo", "->", "FramePointerSaveIndex", ")", "{", "const", "int", "FI", "=", "FuncInfo", "->", "FramePointerSaveIndex", ".", "getValue", "(", ")", ";", "assert", "(", "!", "MFI", ".", "isDeadObjectIndex", "(", "FI", ")", "&&", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "ArrayRef", "<", "SIMachineFunctionInfo", "::", "SpilledReg", ">", "Spill", "=", "FuncInfo", "->", "getSGPRToVGPRSpills", "(", "FI", ")", ";", "assert", "(", "Spill", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "getMCOpcodeFromPseudo", "(", "AMDGPU", "::", "V_WRITELANE_B32", ")", ",", "Spill", "[", "<NUM_LIT>", "]", ".", "VGPR", ")", ".", "addReg", "(", "FramePtrReg", ")", ".", "addImm", "(", "Spill", "[", "<NUM_LIT>", "]", ".", "Lane", ")", ".", "addReg", "(", "Spill", "[", "<NUM_LIT>", "]", ".", "VGPR", ",", "RegState", "::", "Undef", ")", ";", "}", "if", "(", "TRI", ".", "needsStackRealignment", "(", "MF", ")", ")", "{", "HasFP", "=", "true", ";", "const", "unsigned", "Alignment", "=", "MFI", ".", "getMaxAlign", "(", ")", ".", "value", "(", ")", ";", "RoundedSize", "+=", "Alignment", ";", "if", "(", "LiveRegs", ".", "empty", "(", ")", ")", "{", "LiveRegs", ".", "init", "(", "TRI", ")", ";", "LiveRegs", ".", "addLiveIns", "(", "MBB", ")", ";", "LiveRegs", ".", "addReg", "(", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", ";", "}", "Register", "ScratchSPReg", "=", "findScratchNonCalleeSaveRegister", "(", "MRI", ",", "LiveRegs", ",", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "assert", "(", "ScratchSPReg", "!=", "AMDGPU", "::", "NoRegister", "&&", "ScratchSPReg", "!=", "FuncInfo", "->", "SGPRForFPSaveRestoreCopy", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "ScratchSPReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "(", "Alignment", "-", "<NUM_LIT>", ")", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_AND_B32", ")", ",", "FramePtrReg", ")", ".", "addReg", "(", "ScratchSPReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "-", "Alignment", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "FuncInfo", "->", "setIsStackRealigned", "(", "true" ]

[ "_", "B", ",", "_", "mm512_undefined_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_getmant_round_pd", "(", "_", "_", "m512d", "_", "_", "A", ",", "_", "MM_MANTISSA_NORM_ENUM", "_", "_", "B", ",", "_", "MM_MANTISSA_SIGN_ENUM", "_", "_", "C", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_getmantpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "C", "<<", "<NUM_LIT>", ")", "|", "_" ]

[ "}", "else", "{" ]

[ "MCSymbol", "*", "RetSymbol", "=", "MF", ".", "getContext", "(", ")", ".", "createTempSymbol", "(", "<STR_LIT>", "slh_ret_addr", "<STR_LIT>", ",", "true", ")", ";", "MI", ".", "setPostInstrSymbol", "(", "MF", ",", "RetSymbol", ")", ";", "const", "TargetRegisterClass", "*", "AddrRC", "=", "&", "X86", "::", "GR64RegClass", ";", "unsigned", "ExpectedRetAddrReg", "=", "<NUM_LIT>", ";", "if", "(", "!", "Subtarget", "->", "getFrameLowering", "(", ")", "->", "has128ByteRedZone", "(", "MF", ")", "||", "MF", ".", "exposesReturnsTwice", "(", ")", ")", "{", "ExpectedRetAddrReg", "=", "MRI", "->", "createVirtualRegister", "(", "AddrRC", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "&&", "!", "Subtarget", "->", "isPositionIndependent", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "Loc", ",", "TII", "->", "get", "(", "X86", "::", "MOV64ri32", ")", ",", "ExpectedRetAddrReg", ")", ".", "addSym", "(", "RetSymbol", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "Loc", ",", "TII", "->", "get", "(", "X86", "::", "LEA64r", ")", ",", "ExpectedRetAddrReg", ")", ".", "addReg", "(", "X86", "::", "RIP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addSym", "(", "RetSymbol", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "}", "}", "++", "InsertPt", ";", "if", "(", "!", "ExpectedRetAddrReg", ")", "{", "ExpectedRetAddrReg", "=", "MRI", "->", "createVirtualRegister", "(", "AddrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "Loc", ",", "TII", "->", "get", "(", "X86", "::", "MOV64rm", ")", ",", "ExpectedRetAddrReg", ")", ".", "addReg", "(", "X86", "::", "RSP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "}", "unsigned", "NewStateReg", "=", "extractPredStateFromSP", "(", "MBB", ",", "InsertPt", ",", "Loc", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "&&", "!", "Subtarget", "->", "isPositionIndependent", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "Loc", ",", "TII", "->", "get", "(", "X86", "::", "CMP64ri32", ")", ")", ".", "addReg", "(", "ExpectedRetAddrReg", ",", "RegState", "::", "Kill", ")", ".", "addSym", "(", "RetSymbol", ")", ";" ]

[ "<FIXS>", "pic_ref", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "INTVAL", "(", "or", "ig", ")", ")", ";", "<FIXE>" ]

[ "base", "==", "reg", "?", "<NUM_LIT>", ":", "reg", ")", ";", "if", "(", "GET_CODE", "(", "or", "ig", ")", "==", "CONST_INT", ")", "<BUGS>", "pic_ref", "=", "plus_constant", "(", "base", ",", "INTVAL", "(", "or", "ig", ")", ")", ";", "<BUGE>", "elsepic_ref", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "or", "ig", ")", ";", "}" ]

[ ";" ]

[ "class", "MSA_BIT_B_DESC_BASE", "<", "string", "instr_asm", ",", "SDPatternOperator", "OpNode", ",", "ComplexPattern", "Imm", ",", "RegisterOperand", "ROWD", ",", "RegisterOperand", "ROWS", "=", "ROWD", ",", "InstrItinClass", "itin", "=", "NoItinerary", ">", "{", "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWS", ":", "$", "ws", ",", "vsplat_uimm3", ":", "$", "m", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "OpNode", "ROWS", ":", "$", "ws", ",", "Imm", ":", "$", "m", ")", ")", "]", ";", "InstrItinClass", "Itinerary", "=", "itin" ]

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";" ]

[ "def", "J4_cmpeq_fp0_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "GeneralSubRegs", ":", "$", "Rt16", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56336eb0", ",", "TypeCJ", ">", ",", "Enc_6a5972", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";" ]

[ "let", "isTerminator", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";" ]

[ "Expr", ")", ";" ]

[ "Kind", "=", "MCSymbolRefExpr", "::", "VK_WASM_TLSREL", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "Kind", "=", "MCSymbolRefExpr", "::", "VK_WASM_TBREL", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown target flag on GV operand", "<STR_LIT>", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Kind", ",", "Ctx", ")", ";", "if", "(", "MO", ".", "getOffset", "(", ")", "!=", "<NUM_LIT>", ")", "{", "const", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Sym", ")", ";", "if", "(", "TargetFlags", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "GOT symbol references do not support offsets", "<STR_LIT>", ")", ";", "if", "(", "WasmSym", "->", "isFunction", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Function addresses with offsets not supported", "<STR_LIT>", ")", ";", "if", "(", "WasmSym", "->", "isGlobal", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Global indexes with offsets not supported", "<STR_LIT>", ")", ";", "if", "(", "WasmSym", "->", "isEvent", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Event indexes with offsets not supported", "<STR_LIT>", ")", ";", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "MO", ".", "getOffset", "(", ")", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "return", "MCOperand", "::", "createExpr", "(" ]

[ "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";" ]

[ "TargetLoweringBase", "::", "LegalizeTypeAction", "SITargetLowering", "::", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "!=", "<NUM_LIT>", "&&", "VT", ".", "getScalarType", "(", ")", ".", "bitsLE", "(", "MVT", "::", "i16", ")", ")", "return", "TypeSplitVector", ";" ]

[ "return", "VectorList", ".", "Count", "==", "<NUM_LIT>", "&&", "VectorList", ".", "LaneIndex", "<=", "<NUM_LIT>", ";" ]

[ "bool", "isVecListOneDHWordIndexed", "(", ")", "const", "{", "if", "(", "!", "isSingleSpacedVectorIndexed", "(", ")", ")", "return", "false", ";" ]

[ "i", "]", ",", "PartPtr", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "}", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "<", "<NUM_LIT>", ";", "++", "j", ")", "{", "Values", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "DL", ",", "MVT", "::", "i32", ",", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "DL", ",", "MVT", "::", "i64", ",", "Store", "->", "getValue", "(", ")", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i32", ")", ")", ",", "DAG", ".", "getConstant", "(", "j", ",", "MVT", "::", "i32", ")", ")", ")", ";", "}", "}", "}", "else", "{", "Values", ".", "push_back", "(", "Store", "->", "getValue", "(", ")", ")", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Values", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "PartPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i32", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ",", "Values", "[" ]

[ "<NUM_LIT>", ";" ]

[ "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=" ]

[ "shouldEmitFixup", "(", "GV", ")", "&&", "!", "getTargetMachine", "(", ")", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ";" ]

[ "return", "(", "GV", "->", "getValueType", "(", ")", "->", "isFunctionTy", "(", ")", "||", "!", "isNonGlobalAddrSpace", "(", "GV", "->", "getAddressSpace", "(", ")", ")", ")", "&&", "!" ]

[ "<FIXS>", "let", "PredicateMethod", "=", "<STR_LIT>", ";", "<FIXE>" ]

[ "class", "GDSBaseMatchClass", "string", "parser", ">", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", "#", "parser", ";", "<BUGS>", "let", "PredicateMethod", "=", "<STR_LIT>", ";", "<BUGE>", "let", "ParserMethod", "=", "parser", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";", "let", "IsOptional", "=", "<NUM_LIT>", ";" ]

[ ",", "Sched", "<", "[", "sched", ".", "XMM", "]", ">", ";" ]

[ "def", "rr", ":", "SS38I", "<", "opc", ",", "MRMSrcReg", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "VR128", ":", "$", "src", ")", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "vt", "(", "OpNode", "VR128", ":", "$", "src", ")", ")", ")", "]", ">" ]

[ ")", "]", ")" ]

[ "(", "zero_extend", ":", "DI", "(", "truncate", ":", "SI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "!", "strict_p", ")", "return", "true", ";" ]

[ "bool", "pru_regno_ok_for_base_p", "(", "int", "regno", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "HARD_REGISTER_NUM_P", "(", "regno", ")", "&&" ]

[ "=", "<NUM_LIT>", ";" ]

[ "def", "A2_addsp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", "{", "let", "isPseudo" ]

[ "}" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "I2", ";", "bits", "<", "<NUM_LIT>", ">", "M3", ";", "bits", "<", "<NUM_LIT>", ">", "RI4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RI4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "I2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "printUImm", "<NUM_LIT>", ">", "(", "MI", ",", "i", ",", "O", ")", ";", "<FIXE>" ]

[ "if", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "printRegName", "(", "O", ",", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ";", "else", "<BUGS>", "printUnsignedImm", "(", "MI", ",", "i", ",", "O", ")", ";", "<BUGE>", "}", "}" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "<", "MODE", ">", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "DI", "(", "match_operand", ":", "DFP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{" ]

[ "}" ]

[ "}", "hwmult_options", "[", "]", "=", "{", "{", "<STR_LIT>", "none", "<STR_LIT>", ",", "<STR_LIT>", "-lmul_none", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "auto", "<STR_LIT>", ",", "<STR_LIT>", "-lmul_AUTO", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "-lmul_16", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "-lmul_32", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "f5series", "<STR_LIT>", ",", "<STR_LIT>", "-lmul_f5", "<STR_LIT>", "}", "}", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "hwmult_options", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "argv", "[", "argc", "-", "<NUM_LIT>", "]", ",", "hwmult_options", "[", "i", "]", ".", "name", ")", "==", "<NUM_LIT>", ")", "return", "hwmult_options", "[", "i", "]", ".", "lib", ";", "}", "else", "if", "(", "strcasecmp", "(", "argv", "[", "<NUM_LIT>", "]", ",", "<STR_LIT>", "mcu", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "msp430_extract_mcu_data", "(", "argv", "[", "argc", "-", "<NUM_LIT>", "]", ")", ";", "if", "(", "extracted_mcu_data", ".", "name", "!=", "NULL", ")", "{", "switch", "(", "extracted_mcu_data", ".", "hwmpy", ")", "{", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "-lmul_none", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "-lmul_16", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "-lmul_32", "<STR_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "-lmul_f5", "<STR_LIT>", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}" ]

[ ")" ]

[ "(", "vec_select", ":", "V16HI", "(", "match_operand", ":", "V16HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "selectMBB", "(", "MBB", ")", ";", "return", "Modified", ";" ]

[ "<", "CombineInfo", ">>", "MergeableInsts", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Running SILoadStoreOptimizer\\n", "<STR_LIT>", ")", ";", "bool", "Modified", "=", "false", ";", "SmallPtrSet", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "AnchorList", ";", "MemInfoMap", "Visited", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "SectionEnd", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "SectionEnd", ")", "{", "bool", "CollectModified", ";", "std", "::", "list", "<", "std", "::", "list" ]

[ ">", "]", ">", ">", ";" ]

[ "def", "NEONvduplane", ":", "SDNode", "<", "<STR_LIT>", ",", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVec", "<", "<NUM_LIT>", ">", ",", "SDTCisVec", "<", "<NUM_LIT>", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i32" ]

[ "(", ")", ";" ]

[ "for", "(", "unsigned", "Op", ":", "Ops", ")", "{", "int", "OperandIdx", "=", "TII", "->", "getOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "Op", ")", ";", "if", "(", "OperandIdx", "<", "<NUM_LIT>", ")", "continue", ";", "Register", "Src", "=", "MI", ".", "getOperand", "(", "OperandIdx", ")", ".", "getReg" ]

[ "<FIXS>", "static", "int", "sh_adjust_cost", "(", "rtx_insn", "*", ",", "rtx", ",", "rtx_insn", "*", ",", "int", ")", ";", "<FIXE>", "<FIXS>", "static", "int", "sh_dfa_new_cycle", "(", "FILE", "*", ",", "int", ",", "rtx_insn", "*", ",", "int", ",", "int", ",", "int", "*", "sort_p", ")", ";", "<FIXE>" ]

[ "static", "void", "sh_insert_attributes", "(", "tree", ",", "tree", "*", ")", ";", "static", "const", "char", "*", "sh_check_pch_target_flags", "(", "int", ")", ";", "static", "int", "sh_register_move_cost", "(", "enum", "machine_mode", ",", "reg_class_t", ",", "reg_class_t", ")", ";", "<BUGS>", "static", "int", "sh_adjust_cost", "(", "rtx", ",", "rtx", ",", "rtx", ",", "int", ")", ";", "<BUGE>", "static", "int", "sh_issue_rate", "(", "void", ")", ";", "<BUGS>", "static", "int", "sh_dfa_new_cycle", "(", "FILE", "*", ",", "int", ",", "rtx", ",", "int", ",", "int", ",", "int", "*", "sort_p", ")", ";", "<BUGE>", "static", "short", "find_set_regmode_weight", "(", "rtx", ",", "enum", "machine_mode", ")", ";", "static", "short", "find_insn_regmode_weight", "(", "rtx", ",", "enum", "machine_mode", ")", ";", "static", "void", "find_regmode_weight", "(", "basic_block", ",", "enum", "machine_mode", ")", ";" ]

[ "MVT", "ConcatTy", "=", "MVT", "::", "getVectorVT", "(", "RHSTy", ".", "getVectorElementType", "(", ")", ",", "RHSTy", ".", "getVectorNumElements", "(", ")", "*", "<NUM_LIT>", ")", ";" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "N", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "N0", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", "&&", "N1", "->", "getOpcode", "(", ")", "==", "ISD", "::", "TRUNCATE", ")", "{", "SDValue", "N00", "=", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N10", "=", "N1", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "N00VT", "=", "N00", ".", "getValueType", "(", ")", ";", "if", "(", "N00VT", "==", "N10", ".", "getValueType", "(", ")", "&&", "(", "N00VT", "==", "MVT", "::", "v2i64", "||", "N00VT", "==", "MVT", "::", "v4i32", ")", "&&", "N00VT", ".", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", "*", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "MVT", "MidVT", "=", "(", "N00VT", "==", "MVT", "::", "v2i64", "?", "MVT", "::", "v4i32", ":", "MVT", "::", "v8i16", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Mask", "(", "MidVT", ".", "getVectorNumElements", "(", ")", ")", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "Mask", ".", "size", "(", ")", ";", "++", "i", ")", "Mask", "[", "i", "]", "=", "i", "*", "<NUM_LIT>", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VT", ",", "DAG", ".", "getVectorShuffle", "(", "MidVT", ",", "dl", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MidVT", ",", "N00", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MidVT", ",", "N10", ")", ",", "Mask", ")", ")", ";", "}", "}", "if", "(", "DCI", ".", "isBeforeLegalizeOps", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "N0", "==", "N1", "&&", "VT", ".", "getVectorNumElements", "(", ")", "==", "<NUM_LIT>", ")", "{", "assert", "(", "VT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "WidenVector", "(", "N0", ",", "DAG", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i64", ")", ")", ";", "}", "if", "(", "N1", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "BITCAST", ")", "return", "SDValue", "(", ")", ";", "SDValue", "RHS", "=", "N1", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MVT", "RHSTy", "=", "RHS", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "if", "(", "!", "RHSTy", ".", "isVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "aarch64-lower: concat_vectors bitcast simplification\\n", "<STR_LIT>", ")", ";" ]

[ "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "(", "clobber", "(", "reg", ":", "SI", "T_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "R1_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "PR_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "MACH_REG", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "MACL_REG", ")", ")", "(", "use", "(", "match_operand", ":", "SI" ]

[ "else", "return", "regno_to_class", "[", "regno", "]", ";" ]

[ "enum", "reg_class", "xtensa_regno_to_class", "(", "int", "regno", ")", "{", "static", "const", "enum", "reg_class", "regno_to_class", "[", "FIRST_PSEUDO_REGISTER", "]", "=", "{", "RL_REGS", ",", "SP_REG", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "RL_REGS", ",", "AR_REGS", ",", "AR_REGS", ",", "BR_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "FP_REGS", ",", "ACC_REG", ",", "}", ";", "if", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "GR_REGS", ";" ]

[ "}" ]

[ "if", "(", "ShiftMO", ".", "getImm", "(", ")", "!=", "<NUM_LIT>", ")", "O", "<<", "<STR_LIT>", ", lsl #", "<STR_LIT>", "<<", "(", "ShiftMO", ".", "getImm", "(", ")", "*", "<NUM_LIT>", ")", ";", "return", ";", "}", "O", "<<", "<STR_LIT>", "#", "<STR_LIT>", "<<", "*", "UImm16MO", ".", "getExpr", "(", ")", ";" ]

[ ")" ]

[ "(", "define_constraint", "<STR_LIT>", "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", ")" ]

[ "<NUM_LIT>", ";" ]

[ "def", "F2_conv_df2ud_chop", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isFP", "=" ]

[ "OtherBB", ".", "addLiveIn", "(", "ScratchWaveOffsetReg", ")", ";" ]

[ "if", "(", "!", "ST", ".", "hasSGPRInitBug", "(", ")", ")", "{", "if", "(", "ScratchRsrcReg", "==", "TRI", "->", "reservedPrivateSegmentBufferReg", "(", "MF", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "NumPreloaded", "=", "MFI", "->", "getNumPreloadedSGPRs", "(", ")", "/", "<NUM_LIT>", ";", "for", "(", "MCPhysReg", "Reg", ":", "getAllSGPR128", "(", ")", ".", "drop_back", "(", "<NUM_LIT>", ")", ".", "slice", "(", "NumPreloaded", ")", ")", "{", "if", "(", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "{", "assert", "(", "MRI", ".", "isAllocatable", "(", "Reg", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchRsrcReg", ",", "Reg", ")", ";", "ScratchRsrcReg", "=", "Reg", ";", "MFI", "->", "setScratchRSrcReg", "(", "ScratchRsrcReg", ")", ";", "break", ";", "}", "}", "}", "if", "(", "ScratchWaveOffsetReg", "==", "TRI", "->", "reservedPrivateSegmentWaveByteOffsetReg", "(", "MF", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "NumPreloaded", "=", "MFI", "->", "getNumPreloadedSGPRs", "(", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "getAllSGPRs", "(", ")", ".", "drop_back", "(", "<NUM_LIT>", ")", ".", "slice", "(", "NumPreloaded", ")", ")", "{", "if", "(", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "{", "if", "(", "!", "MRI", ".", "isAllocatable", "(", "Reg", ")", "||", "TRI", "->", "isSubRegisterEq", "(", "ScratchRsrcReg", ",", "Reg", ")", ")", "continue", ";", "MRI", ".", "replaceRegWith", "(", "ScratchWaveOffsetReg", ",", "Reg", ")", ";", "ScratchWaveOffsetReg", "=", "Reg", ";", "MFI", "->", "setScratchWaveOffsetReg", "(", "ScratchWaveOffsetReg", ")", ";", "break", ";", "}", "}", "}", "}", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "ScratchRsrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "const", "MCInstrDesc", "&", "SMovB32", "=", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ";", "DebugLoc", "DL", ";", "if", "(", "PreloadedScratchWaveOffsetReg", "!=", "ScratchWaveOffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB32", ",", "ScratchWaveOffsetReg", ")", ".", "addReg", "(", "PreloadedScratchWaveOffsetReg", ",", "RegState", "::", "Kill", ")", ";", "}", "if", "(", "ST", ".", "isAmdHsaOS", "(", ")", ")", "{", "assert", "(", "!", "TRI", "->", "isSubRegisterEq", "(", "PreloadedPrivateBufferReg", ",", "ScratchRsrcReg", ")", "&&", "!", "TRI", "->", "isSubRegisterEq", "(", "PreloadedPrivateBufferReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "unsigned", "Rsrc01", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub0_sub1", ")", ";", "unsigned", "Rsrc23", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub2_sub3", ")", ";", "unsigned", "Lo", "=", "TRI", "->", "getSubReg", "(", "PreloadedPrivateBufferReg", ",", "AMDGPU", "::", "sub0_sub1", ")", ";", "unsigned", "Hi", "=", "TRI", "->", "getSubReg", "(", "PreloadedPrivateBufferReg", ",", "AMDGPU", "::", "sub2_sub3", ")", ";", "const", "MCInstrDesc", "&", "SMovB64", "=", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB64", ",", "Rsrc01", ")", ".", "addReg", "(", "Lo", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB64", ",", "Rsrc23", ")", ".", "addReg", "(", "Hi", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "unsigned", "Rsrc0", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "Rsrc1", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub1", ")", ";", "unsigned", "Rsrc2", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub2", ")", ";", "unsigned", "Rsrc3", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub3", ")", ";", "uint64_t", "Rsrc23", "=", "TII", "->", "getScratchRsrcWords23", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB32", ",", "Rsrc0", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "SCRATCH_RSRC_DWORD0", "<STR_LIT>", ")", ".", "addReg", "(", "ScratchRsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB32", ",", "Rsrc1", ")", ".", "addExternalSymbol", "(", "<STR_LIT>", "SCRATCH_RSRC_DWORD1", "<STR_LIT>", ")", ".", "addReg", "(", "ScratchRsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB32", ",", "Rsrc2", ")", ".", "addImm", "(", "Rsrc23", "&", "<NUM_LIT>", ")", ".", "addReg", "(", "ScratchRsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "SMovB32", ",", "Rsrc3", ")", ".", "addImm", "(", "Rsrc23", ">>", "<NUM_LIT>", ")", ".", "addReg", "(", "ScratchRsrcReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "for", "(", "MachineBasicBlock", "&", "OtherBB", ":", "MF", ")", "{", "if", "(", "&", "OtherBB", "==", "&", "MBB", ")", "continue", ";", "OtherBB", ".", "addLiveIn", "(", "ScratchRsrcReg", ")", ";" ]

[ "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";" ]

[ "case", "TargetOpcode", "::", "G_SELECT", ":" ]

[ "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "case", "TargetOpcode", "::", "G_PHI", ":" ]

[ "<FIXS>", "isARMFunc", "=", "!", "Subtarget", "->", "isThumb", "(", ")", "||", "(", "isStub", "&&", "!", "Subtarget", "->", "isMClass", "(", ")", ")", ";", "<FIXE>" ]

[ "isDirect", "=", "true", ";", "bool", "isStub", "=", "Subtarget", "->", "isTargetMachO", "(", ")", "&&", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ";", "<BUGS>", "isARMFunc", "=", "!", "Subtarget", "->", "isThumb", "(", ")", "||", "isStub", ";", "<BUGE>", "const", "char", "*", "Sym", "=", "S", "->", "getSymbol", "(", ")", ";", "if", "(", "isARMFunc", "&&", "Subtarget", "->", "isThumb1Only", "(", ")", "&&", "!", "Subtarget", "->", "hasV5TOps", "(", ")", ")", "{" ]

[ "V128", ":", "$", "src1", ")", ",", "<NUM_LIT>", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", "#", "<STR_LIT>", ",", "(", "CMGTv2i64", "V128", ":", "$", "dst", ",", "V128", ":", "$", "src2", "," ]

[ "<FIXS>", "const", "int", "x86_inter_unit_moves", "=", "~", "(", "m_ATHLON_K8_AMDFAM10", "|", "m_GENERIC", ")", ";", "<FIXE>" ]

[ "const", "int", "x86_use_ffreep", "=", "m_ATHLON_K8_AMDFAM10", ";", "const", "int", "x86_use_incdec", "=", "~", "(", "m_PENT4", "|", "m_NOCONA", "|", "m_CORE2", "|", "m_GENERIC", ")", ";", "<BUGS>", "const", "int", "x86_inter_unit_moves", "=", "<NUM_LIT>", ";", "<BUGE>", "const", "int", "x86_ext_80387_constants", "=", "m_K6_GEODE", "|", "m_ATHLON_K8", "|", "m_PENT4", "|", "m_NOCONA", "|", "m_PPRO", "|", "m_CORE2", "|", "m_GENERIC", ";" ]

[ "<FIXS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "<NUM_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "II", ";" ]

[ "}" ]

[ "if", "(", "is_attribute_p", "(", "<STR_LIT>", "fast_interrupt", "<STR_LIT>", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "<NUM_LIT>", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "<NUM_LIT>", ";" ]

[ ",", "OpIdx", ")", ";" ]

[ "assert", "(", "(", "Binary", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "Binary", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "Binary", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "VFP encoding bug!", "<STR_LIT>", ")", ";", "Binary", "|=", "encodeVFPRd", "(", "MI", ",", "OpIdx", "++", ")", ";", "if", "(", "TID", ".", "getOperandConstraint", "(", "OpIdx", ",", "TOI", "::", "TIED_TO", ")", "!=", "-", "<NUM_LIT>", ")", "++", "OpIdx", ";", "if", "(", "(", "TID", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Binary", "|=", "encodeVFPRn", "(", "MI", ",", "OpIdx", "++", ")", ";", "if", "(", "OpIdx", "==", "TID", ".", "getNumOperands", "(", ")", "||", "TID", ".", "OpInfo", "[", "OpIdx", "]", ".", "isPredicate", "(", ")", "||", "TID", ".", "OpInfo", "[", "OpIdx", "]", ".", "isOptionalDef", "(", ")", ")", "{", "emitWordLE", "(", "Binary", ")", ";", "return", ";", "}", "Binary", "|=", "encodeVFPRm", "(", "MI" ]

[ ")", ";" ]

[ "vclezq_s16", "(", "int16x8_t", "_", "_", "a", ")", "{", "return", "(", "uint16x8_t", ")", "(", "_", "_", "a", "<=", "<NUM_LIT>" ]

[ "}" ]

[ "def", "Xrri", ":", "BaseExtractImm", "<", "GPR64", ",", "imm0_63", ",", "asm", ",", "[", "(", "set", "GPR64", ":", "$", "Rd", ",", "(", "ARM64Extr", "GPR64", ":", "$", "Rn", ",", "GPR64", ":", "$", "Rm", ",", "imm0_63", ":", "$", "imm", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "bit_off", ";", "bits", "<", "<NUM_LIT>", ">", "target", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "bit_off", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "target", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";" ]

[ ")", "}", ";" ]

[ "LLVMContext", "&", "Ctx", "=", "F", ".", "getContext", "(", ")", ";", "IntegerType", "*", "I16", "=", "Type", "::", "getInt16Ty", "(", "Ctx", ")", ";", "FunctionType", "*", "FnType", "=", "FunctionType", "::", "get", "(", "Type", "::", "getVoidTy", "(", "Ctx", ")", ",", "{", "Type", "::", "getInt8PtrTy", "(", "Ctx", ")", ",", "I16", "}", ",", "false", ")", ";", "Constant", "*", "Fn", "=", "F", ".", "getParent", "(", ")", "->", "getOrInsertFunction", "(", "SymName", ",", "FnType", ")", ";", "Value", "*", "FunctionName", "=", "CreateStringPtr", "(", "BB", ",", "F", ".", "getName", "(", ")", ")", ";", "Value", "*", "Args", "[", "]", "=", "{", "FunctionName", ",", "ConstantInt", "::", "get", "(", "I16", ",", "F", ".", "arg_size", "(", ")" ]

[ "<STR_LIT>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "CC_CCR", "[", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_CR_LOGIC", ")", ")", "]" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "SI Shrink Instructions", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "<FIXS>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_LTU", "(", "DWI", ">", "mode", ",", "cc", ",", "const0_rtx", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_LTU", "(", "MODE", ">", "mode", ",", "cc", ",", "const0_rtx", ")", "<FIXE>" ]

[ "<STR_LIT>", "{", "rtx", "cc", "=", "gen_rtx_REG", "(", "CC_Cmode", ",", "CC_REGNUM", ")", "<BUGS>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_NE", "(", "DWI", ">", "mode", ",", "cc", ",", "const0_rtx", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_NE", "(", "MODE", ">", "mode", ",", "cc", ",", "const0_rtx", ")", "<BUGE>", "}", ")", "(", "define_insn", "<STR_LIT>" ]

[ "return", "GET_CODE", "(", "value", ")", "==", "HIGH", ";" ]

[ "switch", "(", "c", ")", "{", "case", "'", "Q", "'", ":", "return", "normal_memory_operand", "(", "value", ",", "VOIDmode", ")", ";", "case", "'", "R", "'", ":", "return", "direct_call_operand", "(", "value", ",", "Pmode", ")", ";", "case", "'", "S", "'", ":", "return", "(", "GET_CODE", "(", "value", ")", "==", "CONST_INT", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "value", ")", "<", "<NUM_LIT>", ")", ";", "case", "'", "T", "'", ":" ]

[ "}" ]

[ "const", "StringRef", "ChkStkStubSymbol", "=", "<STR_LIT>", "__chkstk_stub", "<STR_LIT>", ";", "MachineInstr", "*", "ChkStkStub", "=", "nullptr", ";", "for", "(", "MachineInstr", "&", "MI", ":", "PrologMBB", ")", "{", "if", "(", "MI", ".", "isCall", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isSymbol", "(", ")", "&&", "ChkStkStubSymbol", "==", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSymbolName", "(", ")", ")", "{", "ChkStkStub", "=", "&", "MI", ";", "break", ";", "}", "}", "if", "(", "ChkStkStub", "!=", "nullptr", ")", "{", "assert", "(", "!", "ChkStkStub", "->", "isBundled", "(", ")", "&&", "<STR_LIT>", "Not expecting bundled instructions here", "<STR_LIT>", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "next", "(", "ChkStkStub", "->", "getIterator", "(", ")", ")", ";", "assert", "(", "std", "::", "prev", "(", "MBBI", ")", "==", "ChkStkStub", "&&", "<STR_LIT>", "MBBI expected after __chkstk_stub.", "<STR_LIT>", ")", ";", "DebugLoc", "DL", "=", "PrologMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "emitStackProbeInline", "(", "MF", ",", "PrologMBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "ChkStkStub", "->", "eraseFromParent", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", ":", "SI", "(", "not", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "not", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "vsub_u64", "(", "uint64x1_t", "_", "_", "a", ",", "uint64x1_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "-", "_", "_", "b", ";" ]

[ "<FIXS>", "(", "plus", ":", "V4SI", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "plus", ":", "V4SI", "<BUGE>", "(", "mult", ":", "V4SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "emit_move_insn", "(", "new", "_", "mode", ",", "reg", ")", ";" ]

[ "rtx", "reg", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_x86_fnstcw_1", "(", "stored_mode", ")", ")", ";", "emit_move_insn", "(", "reg", ",", "copy_rtx", "(", "stored_mode", ")", ")", ";", "switch", "(", "mode", ")", "{", "case", "I387_CW_TRUNC", ":", "emit_insn", "(", "gen_iorhi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "slot", "=", "SLOT_CW_TRUNC", ";", "break", ";", "case", "I387_CW_FLOOR", ":", "emit_insn", "(", "gen_andhi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "~", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_iorhi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "slot", "=", "SLOT_CW_FLOOR", ";", "break", ";", "case", "I387_CW_CEIL", ":", "emit_insn", "(", "gen_andhi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "~", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_iorhi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "slot", "=", "SLOT_CW_CEIL", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "slot", "<", "MAX_386_STACK_LOCALS", ")", ";", "new", "_", "mode", "=", "assign_386_stack_local", "(", "HImode", ",", "slot", ")", ";" ]

[ "}" ]

[ "union", "{", "uint32x4x4_t", "_", "_", "i", ";", "_", "_", "builtin_neon_xi", "_", "_", "o", ";", "}", "_", "_", "bu", "=", "{", "_", "_", "b", "}", ";", "_", "_", "builtin_neon_vst1q_x4v4si", "(", "(", "_", "_", "builtin_neon_si", "*", ")", "_", "_", "a", ",", "_", "_", "bu", ".", "_", "_", "o", ")", ";" ]

[ ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";" ]

[ "else", "if", "(", "v2df", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "v3sf", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "v3df", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unknown RegisterClass", "<STR_LIT>", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")" ]

[ "Static", ";" ]

[ "static", "Reloc", "::", "Model", "getEffectiveRelocModel", "(", "const", "Triple", "&", "TT", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ")", "{", "return", "Reloc", "::" ]

[ "mapping", "[", "i", "]", ".", "name", ")", ";" ]

[ "rs6000_file_start", "(", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "ARRAY_SIZE", "(", "rs6000_select", ")", ";", "i", "++", ")", "if", "(", "rs6000_select", "[", "i", "]", ".", "set_arch_p", "&&", "rs6000_select", "[", "i", "]", ".", "string", "&&", "rs6000_select", "[", "i", "]", ".", "string", "[", "<NUM_LIT>", "]", "!=", "'", "\\0", "'", ")", "cpu_id", "=", "rs6000_select", "[", "i", "]", ".", "string", ";", "i", "=", "<NUM_LIT>", ";", "while", "(", "mapping", "[", "i", "]", ".", "arg", "!=", "NULL", "&&", "strcmp", "(", "mapping", "[", "i", "]", ".", "arg", ",", "cpu_id", ")", "!=", "<NUM_LIT>", "&&", "(", "mapping", "[", "i", "]", ".", "if_set", "&", "target_flags", ")", "==", "<NUM_LIT>", ")", "i", "++", ";", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.machine %s\\n", "<STR_LIT>", "," ]

[ "<FIXS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "ltu", ":", "SI", "(", "reg", ":", "CC_C", "CC_REGNUM", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "compare", ":", "CC", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "CC", "CC_REGNUM", ")", "(", "compare", ":", "CC", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "minus", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "(", "match_dup", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "ltu", ":", "SI", "(", "reg", ":", "CC_C", "CC_REGNUM", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ ".", "ElementSize", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zda", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DestructiveInstType", "=", "Destructive", ";", "let", "ElementSize", "=", "zprty" ]

[ "}" ]

[ "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "CondBranches", ";", "return", "analyzeBranchImpl", "(", "MBB", ",", "TBB", ",", "FBB", ",", "Cond", ",", "CondBranches", ",", "AllowModify", ")", ";" ]

[ "}" ]

[ "diag", "(", "pos", ",", "<STR_LIT>", "line length overrun.\\n", "<STR_LIT>", ")", ";", "exit", "(", "<NUM_LIT>", ")", ";", "}" ]

[ "<FIXS>", "mode", "==", "SImode", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "{", "unsigned", "int", "max", "=", "(", "mode", "==", "QImode", "?", "<NUM_LIT>", ":", "mode", "==", "HImode", "?", "<NUM_LIT>", ":", "<BUGS>", "mode", "==", "SImode", "?", "<NUM_LIT>", "U", ":", "<NUM_LIT>", ")", ";", "<BUGE>", "if", "(", "max", "&&", "operator", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "if", "(", "unsigned_condition", "(", "operator", ")", "!=", "operator", ")" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs32", ";" ]

[ "if", "(", "sparc_expand_move", "(", "TImode", ",", "operands", ")", ")" ]

[ "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{" ]

[ "rs", ";" ]

[ "static", "void", "push", "(", "struct", "unw_state_record", "*", "sr", ")", "{", "struct", "unw_reg_state", "*", "rs", "=", "alloc_reg_state", "(", ")", ";", "memcpy", "(", "rs", ",", "&", "sr", "->", "curr", ",", "sizeof", "(", "*", "rs", ")", ")", ";", "sr", "->", "curr", ".", "next", "=" ]

[ ")", ";" ]

[ "int", "ImmVal", "=", "IsDouble", "?", "<STR_LIT>", "::", "<STR_LIT>", "(", "FPVal", ")", ":", "<STR_LIT>", "::", "<STR_LIT>", "(", "FPVal", ")", ";", "if", "(", "ImmVal", "!=", "-", "<NUM_LIT>", ")", "{", "if", "(", "IsDouble", "||", "!", "ST", "->", "useNEONForSinglePrecisionFP", "(", ")", ")", "{", "return", "Op", ";", "}", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "NewVal", "=", "DAG", ".", "getTargetConstant", "(", "ImmVal", ",", "MVT", "::", "i32", ")", ";", "SDValue", "VecConstant", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "v2f32", ",", "NewVal", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "MVT", "::", "f32", ",", "VecConstant", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "}", "if", "(", "!", "ST", "->", "hasNEON", "(", ")", "||", "(", "!", "IsDouble", "&&", "!", "ST", "->", "useNEONForSinglePrecisionFP", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "VMovVT", ";", "uint64_t", "iVal", "=", "FPVal", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ";", "if", "(", "IsDouble", "&&", "(", "iVal", "&", "<NUM_LIT>", ")", "!=", "(", "iVal", ">>", "<NUM_LIT>", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewVal", "=", "isNEONModifiedImm", "(", "iVal", "&", "<NUM_LIT>", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DAG", ",", "VMovVT", ",", "false", ",", "VMOVModImm", ")", ";", "if", "(", "NewVal", "!=", "SDValue", "(", ")", ")", "{", "SDLoc", "DL", "(", "Op" ]

[ "MIB", "=", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "strOpc", ")", ",", "scratch", ")", ".", "addReg", "(", "scratch2", ")", ".", "addReg", "(", "ptr", ")", ";" ]

[ "ldrOpc", "=", "isThumb2", "?", "ARM", "::", "t2LDREXH", ":", "ARM", "::", "LDREXH", ";", "strOpc", "=", "isThumb2", "?", "ARM", "::", "t2STREXH", ":", "ARM", "::", "STREXH", ";", "extendOpc", "=", "isThumb2", "?", "ARM", "::", "t2SXTH", ":", "ARM", "::", "SXTH", ";", "break", ";", "case", "<NUM_LIT>", ":", "ldrOpc", "=", "isThumb2", "?", "ARM", "::", "t2LDREX", ":", "ARM", "::", "LDREX", ";", "strOpc", "=", "isThumb2", "?", "ARM", "::", "t2STREX", ":", "ARM", "::", "STREX", ";", "extendOpc", "=", "<NUM_LIT>", ";", "break", ";", "}", "MachineBasicBlock", "*", "loopMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "exitMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MF", "->", "insert", "(", "It", ",", "loopMBB", ")", ";", "MF", "->", "insert", "(", "It", ",", "exitMBB", ")", ";", "exitMBB", "->", "splice", "(", "exitMBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "exitMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "TargetRegisterClass", "*", "TRC", "=", "isThumb2", "?", "ARM", "::", "tGPRRegisterClass", ":", "ARM", "::", "GPRRegisterClass", ";", "unsigned", "scratch", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "unsigned", "scratch2", "=", "MRI", ".", "createVirtualRegister", "(", "TRC", ")", ";", "BB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "BB", "=", "loopMBB", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "ldrOpc", ")", ",", "dest", ")", ".", "addReg", "(", "ptr", ")", ";", "if", "(", "ldrOpc", "==", "ARM", "::", "t2LDREX", ")", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "if", "(", "signExtend", "&&", "extendOpc", ")", "{", "oldval", "=", "MRI", ".", "createVirtualRegister", "(", "ARM", "::", "GPRRegisterClass", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "extendOpc", ")", ",", "oldval", ")", ".", "addReg", "(", "dest", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "}", "AddDefaultPred", "(", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "isThumb2", "?", "ARM", "::", "t2CMPrr", ":", "ARM", "::", "CMPrr", ")", ")", ".", "addReg", "(", "oldval", ")", ".", "addReg", "(", "incr", ")", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "isThumb2", "?", "ARM", "::", "t2MOVCCr", ":", "ARM", "::", "MOVCCr", ")", ",", "scratch2", ")", ".", "addReg", "(", "oldval", ")", ".", "addReg", "(", "incr", ")", ".", "addImm", "(", "Cond", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ")", ";" ]

[ "<FIXS>", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashiftrt", ":", "V8HI", "(", "match_operand", ":", "V8HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}" ]

[ "static", "rtx", "frv_expand_load_builtin", "(", "enum", "insn_code", "icode", ",", "machine_mode", "target_mode", ",", "tree", "call", ",", "rtx", "target", ")", "{", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "<NUM_LIT>", ")", ";", "rtx", "cookie", "=", "frv_io_address_cookie", "(", "op0", ")", ";", "if", "(", "target", "==", "<NUM_LIT>", "||", "!", "REG_P", "(", "target", ")", ")", "target", "=", "gen_reg_rtx", "(", "target_mode", ")", ";", "op0", "=", "frv_volatile_memref", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ",", "op0", ")", ";", "convert_move", "(", "target", ",", "op0", ",", "<NUM_LIT>", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "copy_rtx", "(", "op0", ")", ",", "cookie", ",", "GEN_INT", "(", "FRV_IO_READ", ")", ")", ")", ";", "cfun", "->", "machine", "->", "has_membar_p", "=", "<NUM_LIT>", ";", "return", "target", ";", "}" ]

[ "Expand", "a", "__builtin_read", "*", "function", ".", "ICODE", "is", "the", "instruction", "code", "for", "the", "membar", "and", "TARGET_MODE", "is", "the", "mode", "that", "the", "loaded", "value", "should", "have", "." ]

[ ")", "_", "_", "a", ")", ";" ]

[ "return", "(", "int16x4_t", ")", "_", "_", "builtin_neon_vcreatev4hi", "(", "(", "_", "_", "builtin_neon_di" ]

[ "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "vsliq_n_s32", "(", "int32x4_t", "_", "_", "a", ",", "int32x4_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "int32x4_t", ")", "_", "_", "builtin_neon_vsli_nv4si", "(", "_", "_", "a", ",", "_" ]

[ "else", "if", "(", "auto", "PType", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ty", ")", ")", "AddrSpace", "=", "PType", "->", "getAddressSpace", "(", ")", ";" ]

[ "}", "if", "(", "auto", "IType", "=", "dyn_cast", "<", "IntegerType", ">", "(", "Ty", ")", ")", "{", "const", "unsigned", "Width", "=", "IType", "->", "getBitWidth", "(", ")", ";", "return", "Width", "==", "<NUM_LIT>", "?", "getOpTypeBool", "(", "MIRBuilder", ")", ":", "getOpTypeInt", "(", "Width", ",", "MIRBuilder", ",", "false", ")", ";", "}", "if", "(", "Ty", "->", "isFloatingPointTy", "(", ")", ")", "return", "getOpTypeFloat", "(", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ",", "MIRBuilder", ")", ";", "if", "(", "Ty", "->", "isVoidTy", "(", ")", ")", "return", "getOpTypeVoid", "(", "MIRBuilder", ")", ";", "if", "(", "Ty", "->", "isVectorTy", "(", ")", ")", "{", "SPIRVType", "*", "El", "=", "findSPIRVType", "(", "cast", "<", "FixedVectorType", ">", "(", "Ty", ")", "->", "getElementType", "(", ")", ",", "MIRBuilder", ")", ";", "return", "getOpTypeVector", "(", "cast", "<", "FixedVectorType", ">", "(", "Ty", ")", "->", "getNumElements", "(", ")", ",", "El", ",", "MIRBuilder", ")", ";", "}", "if", "(", "Ty", "->", "isArrayTy", "(", ")", ")", "{", "SPIRVType", "*", "El", "=", "findSPIRVType", "(", "Ty", "->", "getArrayElementType", "(", ")", ",", "MIRBuilder", ")", ";", "return", "getOpTypeArray", "(", "Ty", "->", "getArrayNumElements", "(", ")", ",", "El", ",", "MIRBuilder", ",", "EmitIR", ")", ";", "}", "if", "(", "auto", "SType", "=", "dyn_cast", "<", "StructType", ">", "(", "Ty", ")", ")", "{", "if", "(", "SType", "->", "isOpaque", "(", ")", ")", "return", "getOpTypeOpaque", "(", "SType", ",", "MIRBuilder", ")", ";", "return", "getOpTypeStruct", "(", "SType", ",", "MIRBuilder", ",", "EmitIR", ")", ";", "}", "if", "(", "auto", "FType", "=", "dyn_cast", "<", "FunctionType", ">", "(", "Ty", ")", ")", "{", "SPIRVType", "*", "RetTy", "=", "findSPIRVType", "(", "FType", "->", "getReturnType", "(", ")", ",", "MIRBuilder", ")", ";", "SmallVector", "<", "SPIRVType", "*", ",", "<NUM_LIT>", ">", "ParamTypes", ";", "for", "(", "const", "auto", "&", "t", ":", "FType", "->", "params", "(", ")", ")", "{", "ParamTypes", ".", "push_back", "(", "findSPIRVType", "(", "t", ",", "MIRBuilder", ")", ")", ";", "}", "return", "getOpTypeFunction", "(", "RetTy", ",", "ParamTypes", ",", "MIRBuilder", ")", ";", "}", "unsigned", "AddrSpace", "=", "<NUM_LIT>", ";", "if", "(", "auto", "PType", "=", "dyn_cast", "<", "TypedPointerType", ">", "(", "Ty", ")", ")", "AddrSpace", "=", "PType", "->", "getAddressSpace", "(", ")", ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "def", "C2_muxri", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "s32_0Imm", ":", "$", "Ii", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_2op", ">", ",", "Enc_e38e1f", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "assert", "(", "Def", "->", "modifiesRegister", "(", "Reg", ",", "this", ")", ")", ";" ]

[ "if", "(", "!", "LIS", "->", "hasInterval", "(", "Reg", ")", ")", "return", "nullptr", ";", "LiveInterval", "&", "LI", "=", "LIS", "->", "getInterval", "(", "Reg", ")", ";", "LaneBitmask", "SubLanes", "=", "SubReg", "?", "getSubRegIndexLaneMask", "(", "SubReg", ")", ":", "MRI", ".", "getMaxLaneMaskForVReg", "(", "Reg", ")", ";", "VNInfo", "*", "V", "=", "nullptr", ";", "if", "(", "LI", ".", "hasSubRanges", "(", ")", ")", "{", "for", "(", "auto", "&", "S", ":", "LI", ".", "subranges", "(", ")", ")", "{", "if", "(", "(", "S", ".", "LaneMask", "&", "SubLanes", ")", "==", "SubLanes", ")", "{", "V", "=", "S", ".", "getVNInfoAt", "(", "UseIdx", ")", ";", "break", ";", "}", "}", "}", "else", "{", "V", "=", "LI", ".", "getVNInfoAt", "(", "UseIdx", ")", ";", "}", "if", "(", "!", "V", ")", "return", "nullptr", ";", "DefIdx", "=", "V", "->", "def", ";", "}", "else", "{", "for", "(", "MCRegUnitIterator", "Units", "(", "Reg", ",", "this", ")", ";", "Units", ".", "isValid", "(", ")", ";", "++", "Units", ")", "{", "LiveRange", "&", "LR", "=", "LIS", "->", "getRegUnit", "(", "*", "Units", ")", ";", "if", "(", "VNInfo", "*", "V", "=", "LR", ".", "getVNInfoAt", "(", "UseIdx", ")", ")", "{", "if", "(", "!", "DefIdx", ".", "isValid", "(", ")", "||", "MDT", ".", "dominates", "(", "LIS", "->", "getInstructionFromIndex", "(", "DefIdx", ")", ",", "LIS", "->", "getInstructionFromIndex", "(", "V", "->", "def", ")", ")", ")", "DefIdx", "=", "V", "->", "def", ";", "}", "else", "{", "return", "nullptr", ";", "}", "}", "}", "MachineInstr", "*", "Def", "=", "LIS", "->", "getInstructionFromIndex", "(", "DefIdx", ")", ";", "if", "(", "!", "Def", "||", "!", "MDT", ".", "dominates", "(", "Def", ",", "&", "Use", ")", ")", "return", "nullptr", ";" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "UNSPEC_VCVTA_S", "<STR_LIT>", ")", "(", "UNSPEC_VCVTA_U", "<STR_LIT>", ")", "(", "UNSPEC_VCVTM_S", "<STR_LIT>", ")", "(", "UNSPEC_VCVTM_U", "<STR_LIT>", ")", "(", "UNSPEC_VCVTN_S", "<STR_LIT>", ")", "(", "UNSPEC_VCVTN_U" ]

[ "(", "clobber", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", ")" ]

[ "(", "define_peephole2", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "ALL2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "ALL2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "b", ")", ";" ]

[ "return", "_", "_", "builtin_mve_vcmpneq_n_fv4sf", "(", "_", "_", "a", ",", "_", "_" ]

[ ";" ]

[ "bool", "TpcLoopOpt", "::", "unrollPragmaValue", "(", "const", "Loop", "*", "L", ")", "{", "if", "(", "GetUnrollMetadataForLoop", "(", "L", ",", "<STR_LIT>", "llvm.loop.unroll.disable", "<STR_LIT>", ")", "||", "GetUnrollMetadataForLoop", "(", "L", ",", "<STR_LIT>", "llvm.loop.unroll.count", "<STR_LIT>", ")", ")", "return", "false", ";", "return", "true" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_add_ss", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_addss_mask_round", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "v4sf", ")", "_", "mm_avx512_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]