Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "abs", ":", "IEEE128", "(", "match_operand", ":", "IEEE128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")" ]

[ "static", "bool", "ix86_check_avx_upper_register", "(", "const_rtx", "exp", ")", "{", "return", "(", "SSE_REG_P", "(", "exp", ")", "&&", "!", "EXT_REX_SSE_REG_P", "(", "exp", ")", "&&", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "exp", ")", ")", ">", "<NUM_LIT>", ")", ";", "}" ]

[ "Check", "if", "a", "256bit", "or", "512", "bit", "AVX", "register", "is", "referenced", "inside", "of", "EXP", "." ]

[ "const", "{" ]

[ "void", "addARMBranchTargetOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "let", "SrcB", "=", "op2", ";" ]

[ "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "and", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Rsrc1", ")", ",", "!", "cast", "<", "string", ">", "(", "Rsrc2", ")", ")", ",", "!", "ne", "(", "!", "cast", "<", "string", ">", "(", "Rsrc2", ")", ",", "<STR_LIT>", ")", ",", "!", "ne", "(", "!", "cast", "<", "string", ">", "(", "Rsrc1", ")", ",", "<STR_LIT>", ")", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";" ]

[ "(", "regno", ">=", "FR_RET_FIRST", "&&", "regno", "<=", "FR_RET_LAST", ")", ")", ";" ]

[ "return", "(", "(", "regno", ">=", "GR_RET_FIRST", "&&", "regno", "<=", "GR_RET_LAST", ")", "||" ]

[ "}" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "]", ";" ]

[ "}" ]

[ "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "AdjustUp", "?", "WebAssembly", "::", "ADD_I32", ":", "WebAssembly", "::", "SUB_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "SPReg", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addExternalSymbol", "(", "SPSymbol", ")", ";", "auto", "*", "MMO", "=", "new", "MachineMemOperand", "(", "MachinePointerInfo", "(", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "STORE_I32", ")", ",", "WebAssembly", "::", "SP32", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "WebAssembly", "::", "SP32", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "true", ")", ";" ]

[ "return", "foldGlobalAddressImpl", "(", "N", ",", "R", "," ]

[ "(", "le", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")" ]

[ "(", "and", "(", "match_test", "<STR_LIT>", ")", "(", "and", "(", "ge", "(", "minus", "(", "match_dup", "<NUM_LIT>", ")", "(", "pc", ")", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")" ]

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

[ "return", "(", "(", "F", ">>", "<STR_LIT>", "::", "<STR_LIT>", ")", "&", "<STR_LIT>", "::" ]

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

[ "(", "fma", ":", "VDF", "(", "match_operand", ":", "VDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VDF", "<NUM_LIT>" ]

[ "Or", ")", ";" ]

[ "MachineInstr", "*", "And", "=", "nullptr", ",", "*", "Or", "=", "nullptr", ";", "if", "(", "!", "SkipAnding", ")", "{", "And", "=", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AndOpc", ")", ",", "Dst", ")", ".", "addReg", "(", "Exec", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Or", "=", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "OrOpc", ")", ",", "Dst", ")", ".", "addReg", "(", "Dst", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "Or", "=", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "DL", ",", "TII", "->", "get", "(", "OrOpc", ")", ",", "Dst", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "LIS", ")", "{", "if", "(", "And", ")", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "And", ")", ";", "LIS", "->", "ReplaceMachineInstrInMaps", "(", "MI", ",", "*" ]

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

[ "def", "condbrtarget", ":", "Operand", "<", "OtherVT", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ ",", "vpred_n", ":", "$", "vp", ")", ",", "<NUM_LIT>", ">", ";" ]

[ "def", "MVE_VORNimmi16", ":", "MVEInstAlias", "<", "<STR_LIT>", ",", "(", "MVE_VORRimmi16", "MQPR", ":", "$", "Qd", ",", "nImmSplatNotI16", ":", "$", "imm" ]

[ ")", "return", "false", ";" ]

[ "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "frameaddress", ":", "{", "MachineFrameInfo", "&", "MFI", "=", "FuncInfo", ".", "MF", "->", "getFrameInfo", "(", ")", ";", "MFI", ".", "setFrameAddressIsTaken", "(", "true", ")", ";", "unsigned", "LdrOpc", "=", "isThumb2", "?", "ARM", "::", "t2LDRi12", ":", "ARM", "::", "LDRi12", ";", "const", "TargetRegisterClass", "*", "RC", "=", "isThumb2", "?", "&", "ARM", "::", "tGPRRegClass", ":", "&", "ARM", "::", "GPRRegClass", ";", "const", "ARMBaseRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "ARMBaseRegisterInfo", "*", ">", "(", "Subtarget", "->", "getRegisterInfo", "(", ")", ")", ";", "Register", "FramePtr", "=", "RegInfo", "->", "getFrameRegister", "(", "*", "(", "FuncInfo", ".", "MF", ")", ")", ";", "unsigned", "SrcReg", "=", "FramePtr", ";", "unsigned", "DestReg", ";", "unsigned", "Depth", "=", "cast", "<", "ConstantInt", ">", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "while", "(", "Depth", "--", ")", "{", "DestReg", "=", "createResultReg", "(", "RC", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "MIMD", ",", "TII", ".", "get", "(", "LdrOpc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "SrcReg", "=", "DestReg", ";", "}", "updateValueMap", "(", "&", "I", ",", "SrcReg", ")", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "memcpy", ":", "case", "Intrinsic", "::", "memmove", ":", "{", "const", "MemTransferInst", "&", "MTI", "=", "cast", "<", "MemTransferInst", ">", "(", "I", ")", ";", "if", "(", "MTI", ".", "isVolatile", "(", ")", ")", "return", "false", ";", "bool", "isMemCpy", "=", "(", "I", ".", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", ")", ";", "if", "(", "isa", "<", "ConstantInt", ">", "(", "MTI", ".", "getLength", "(", ")", ")", "&&", "isMemCpy", ")", "{", "uint64_t", "Len", "=", "cast", "<", "ConstantInt", ">", "(", "MTI", ".", "getLength", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "ARMIsMemCpySmall", "(", "Len", ")", ")", "{", "Address", "Dest", ",", "Src", ";", "if", "(", "!", "ARMComputeAddress", "(", "MTI", ".", "getRawDest", "(", ")", ",", "Dest", ")", "||", "!", "ARMComputeAddress", "(", "MTI", ".", "getRawSource", "(", ")", ",", "Src", ")", ")", "return", "false", ";", "MaybeAlign", "Alignment", ";", "if", "(", "MTI", ".", "getDestAlign", "(", ")", "||", "MTI", ".", "getSourceAlign", "(", ")", ")", "Alignment", "=", "std", "::", "min", "(", "MTI", ".", "getDestAlign", "(", ")", ".", "valueOrOne", "(", ")", ",", "MTI", ".", "getSourceAlign", "(", ")", ".", "valueOrOne", "(", ")", ")", ";", "if", "(", "ARMTryEmitSmallMemCpy", "(", "Dest", ",", "Src", ",", "Len", ",", "Alignment", ")", ")", "return", "true", ";", "}", "}", "if", "(", "!", "MTI", ".", "getLength", "(", ")", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "return", "false", ";", "if", "(", "MTI", ".", "getSourceAddressSpace", "(", ")", ">", "<NUM_LIT>", "||", "MTI", ".", "getDestAddressSpace", "(", ")", ">", "<NUM_LIT>" ]

[ "default", ":" ]

[ "static", "InstrUID", "decode", "(", "OpcodeType", "type", ",", "InstructionContext", "insnContext", ",", "uint8_t", "opcode", ",", "uint8_t", "modRM", ")", "{", "const", "struct", "ModRMDecision", "*", "dec", "=", "<NUM_LIT>", ";", "switch", "(", "type", ")", "{", "case", "ONEBYTE", ":", "dec", "=", "&", "ONEBYTE_SYM", ".", "opcodeDecisions", "[", "insnContext", "]", ".", "modRMDecisions", "[", "opcode", "]", ";", "break", ";", "case", "TWOBYTE", ":", "dec", "=", "&", "TWOBYTE_SYM", ".", "opcodeDecisions", "[", "insnContext", "]", ".", "modRMDecisions", "[", "opcode", "]", ";", "break", ";", "case", "THREEBYTE_38", ":", "dec", "=", "&", "THREEBYTE38_SYM", ".", "opcodeDecisions", "[", "insnContext", "]", ".", "modRMDecisions", "[", "opcode", "]", ";", "break", ";", "case", "THREEBYTE_3A", ":", "dec", "=", "&", "THREEBYTE3A_SYM", ".", "opcodeDecisions", "[", "insnContext", "]", ".", "modRMDecisions", "[", "opcode", "]", ";", "break", ";", "case", "THREEBYTE_A6", ":", "dec", "=", "&", "THREEBYTEA6_SYM", ".", "opcodeDecisions", "[", "insnContext", "]", ".", "modRMDecisions", "[", "opcode", "]", ";", "break", ";", "case", "THREEBYTE_A7", ":", "dec", "=", "&", "THREEBYTEA7_SYM", ".", "opcodeDecisions", "[", "insnContext", "]", ".", "modRMDecisions", "[", "opcode", "]", ";", "break", ";", "}", "switch", "(", "dec", "->", "modrm_type", ")", "{" ]

[ "<FIXS>", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "label", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "label", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "label", ")", ";", "<FIXE>", "<FIXS>", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ",", "GEN_INT", "(", "TLS_IE32", ")", ",", "label", ",", "<FIXE>", "<FIXS>", "emit_insn", "(", "gen_tls_load_dot_plus_eight", "(", "reg", ",", "reg", ",", "labelno", ")", ")", ";", "<FIXE>", "<FIXS>", "emit_insn", "(", "gen_pic_add_dot_plus_four", "(", "reg", ",", "reg", ",", "labelno", ")", ")", ";", "<FIXE>" ]

[ "return", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "addend", ")", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "<BUGS>", "label", "=", "gen_label_rtx", "(", ")", ";", "<BUGE>", "sum", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "<BUGS>", "gen_rtvec", "(", "<NUM_LIT>", ",", "x", ",", "GEN_INT", "(", "TLS_IE32", ")", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ",", "<BUGE>", "GEN_INT", "(", "TARGET_ARM", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ",", "UNSPEC_TLS", ")", ";", "reg", "=", "load_tls_operand", "(", "sum", ",", "reg", ")", ";", "if", "(", "TARGET_ARM", ")", "<BUGS>", "emit_insn", "(", "gen_tls_load_dot_plus_eight", "(", "reg", ",", "reg", ",", "label", ")", ")", ";", "<BUGE>", "else", "{", "<BUGS>", "emit_insn", "(", "gen_pic_add_dot_plus_four", "(", "reg", ",", "reg", ",", "label", ")", ")", ";", "<BUGE>", "emit_move_insn", "(", "reg", ",", "gen_const_mem", "(", "SImode", ",", "reg", ")", ")", ";", "}" ]

[ "<STR_LIT>", ";" ]

[ "def", "MovWSymbolG3AsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=" ]

[ ";" ]

[ "bool", "AArch64TargetLowering", "::", "needsFixedCatchObjects", "(", ")", "const", "{", "return", "false" ]

[ "ENTER_WWM", ":", "{" ]

[ "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B32_V5", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B32_V8", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B32_V16", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B32_V32", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B64_V1", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B64_V2", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B64_V4", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B64_V8", ":", "case", "AMDGPU", "::", "S_INDIRECT_REG_WRITE_B64_V16", ":", "{", "const", "TargetRegisterClass", "*", "EltRC", "=", "getOpRegClass", "(", "MI", ",", "<NUM_LIT>", ")", ";", "unsigned", "Opc", ";", "if", "(", "RI", ".", "hasVGPRs", "(", "EltRC", ")", ")", "{", "Opc", "=", "ST", ".", "useVGPRIndexMode", "(", ")", "?", "AMDGPU", "::", "V_MOV_B32_indirect", ":", "AMDGPU", "::", "V_MOVRELD_B32_e32", ";", "}", "else", "{", "Opc", "=", "RI", ".", "getRegSizeInBits", "(", "*", "EltRC", ")", "==", "<NUM_LIT>", "?", "AMDGPU", "::", "S_MOVRELD_B64", ":", "AMDGPU", "::", "S_MOVRELD_B32", ";", "}", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "Opc", ")", ";", "Register", "VecReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "IsUndef", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isUndef", "(", ")", ";", "unsigned", "SubReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "assert", "(", "VecReg", "==", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "RI", ".", "getSubReg", "(", "VecReg", ",", "SubReg", ")", ",", "RegState", "::", "Undef", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addReg", "(", "VecReg", ",", "RegState", "::", "ImplicitDefine", ")", ".", "addReg", "(", "VecReg", ",", "RegState", "::", "Implicit", "|", "(", "IsUndef", "?", "RegState", "::", "Undef", ":", "<NUM_LIT>", ")", ")", ";", "const", "int", "ImpDefIdx", "=", "OpDesc", ".", "getNumOperands", "(", ")", "+", "OpDesc", ".", "getNumImplicitUses", "(", ")", ";", "const", "int", "ImpUseIdx", "=", "ImpDefIdx", "+", "<NUM_LIT>", ";", "MIB", "->", "tieOperands", "(", "ImpDefIdx", ",", "ImpUseIdx", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_PC_ADD_REL_OFFSET", ":", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "RegLo", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub0", ")", ";", "Register", "RegHi", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub1", ")", ";", "MIBundleBuilder", "Bundler", "(", "MBB", ",", "MI", ")", ";", "Bundler", ".", "append", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "Reg", ")", ")", ";", "Bundler", ".", "append", "(", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "RegLo", ")", ".", "addReg", "(", "RegLo", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ",", "RegHi", ")", ".", "addReg", "(", "RegHi", ")", ";", "MIB", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Bundler", ".", "append", "(", "MIB", ")", ";", "finalizeBundle", "(", "MBB", ",", "Bundler", ".", "begin", "(", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::" ]

[ "bool", "mn10300_match_ccmode", "(", "rtx", "insn", ",", "machine_mode", "cc_mode", ")", "{", "rtx", "op1", ",", "flags", ";", "machine_mode", "flags_mode", ";", "gcc_checking_assert", "(", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ";", "op1", "=", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "gcc_checking_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "op1", ")", ")", "==", "COMPARE", ")", ";", "flags", "=", "SET_DEST", "(", "op1", ")", ";", "flags_mode", "=", "GET_MODE", "(", "flags", ")", ";", "if", "(", "GET_MODE", "(", "SET_SRC", "(", "op1", ")", ")", "!=", "flags_mode", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "flags_mode", ")", "!=", "MODE_CC", ")", "return", "false", ";", "if", "(", "cc_flags_for_mode", "(", "flags_mode", ")", "&", "~", "cc_flags_for_mode", "(", "cc_mode", ")", ")", "return", "false", ";", "return", "true", ";", "}" ]

[ "A", "helper", "function", "for", "matching", "parallels", "that", "set", "the", "flags", "." ]

[ "symbol", ")", ";" ]

[ "if", "(", "!", "MEM_P", "(", "rtl", ")", ")", "return", ";", "symbol", "=", "XEXP", "(", "rtl", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", ";", "flags", "=", "SYMBOL_REF_FLAGS", "(" ]

[ "let", "prefersSlot3", "=", "<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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "{" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "set", "(", "reg", ":", "HI", "<NUM_LIT>", ")", "(", "truncate", ":", "HI", "(", "ffs", ":", "SI", "(", "reg", ":", "SI", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "QI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "QI", "<NUM_LIT>", ")", ")", "]", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

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

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

[ "gen_reg_rtx", "(", "V16QImode", ")" ]

[ "(", "use", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "rtx", "absd", "=" ]

[ "(", "V2SF", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_mode_iterator", "ANYF", "[", "(", "SF", "<STR_LIT>", ")", "(", "DF", "<STR_LIT>", ")" ]

[ "<NUM_LIT>", ";" ]

[ "if", "(", "Op32", "==", "-", "<NUM_LIT>", ")", "return", "false", ";", "return", "pseudoToMCOpcode", "(", "Op32", ")", "!=", "-" ]

[ "}" ]

[ "if", "(", "Val", ".", "PtrTy", "!=", "Query", ".", "Types", "[", "<NUM_LIT>", "]", ")", "continue", ";", "if", "(", "Val", ".", "MemSize", "!=", "Query", ".", "MMODescrs", "[", "<NUM_LIT>", "]", ".", "SizeInBits", ")", "continue", ";", "if", "(", "Val", ".", "MustBeNaturallyAligned", "&&", "Query", ".", "MMODescrs", "[", "<NUM_LIT>", "]", ".", "SizeInBits", "%", "Query", ".", "MMODescrs", "[", "<NUM_LIT>", "]", ".", "AlignInBits", "!=", "<NUM_LIT>", ")", "continue", ";", "return", "true", ";", "}", "return", "false", ";" ]

[ "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lo_sum", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const", ":", "SI", "(", "unspec", ":", "SI", "[" ]

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

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

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "V4QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DPAU_H_QBR", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t" ]

[ "<FIXS>", "const", "MCInstrInfo", "&", "MCII", ";", "const", "MCSubtargetInfo", "&", "STI", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "X86MCCodeEmitter", "(", "const", "MCInstrInfo", "&", "mcii", ",", "const", "MCSubtargetInfo", "&", "sti", ",", "MCContext", "&", "ctx", ")", ":", "MCII", "(", "mcii", ")", ",", "STI", "(", "sti", ")", ",", "Ctx", "(", "ctx", ")", "{", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "llvm/MC/MCCodeEmitter.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/MC/MCExpr.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/MC/MCInst.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/MC/MCSymbol.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/raw_ostream.h", "<STR_LIT>", "using", "namespace", "llvm", ";", "namespace", "{", "class", "X86MCCodeEmitter", ":", "public", "MCCodeEmitter", "{", "X86MCCodeEmitter", "(", "const", "X86MCCodeEmitter", "&", ")", ";", "void", "operator", "=", "(", "const", "X86MCCodeEmitter", "&", ")", ";", "<BUGS>", "const", "TargetMachine", "&", "TM", ";", "const", "TargetInstrInfo", "&", "TII", ";", "<BUGE>", "MCContext", "&", "Ctx", ";", "<BUGS>", "bool", "Is64BitMode", ";", "<BUGE>", "public", ":", "<BUGS>", "X86MCCodeEmitter", "(", "TargetMachine", "&", "tm", ",", "MCContext", "&", "ctx", ",", "bool", "is64Bit", ")", ":", "TM", "(", "tm", ")", ",", "TII", "(", "*", "TM", ".", "getInstrInfo", "(", ")", ")", ",", "Ctx", "(", "ctx", ")", "{", "Is64BitMode", "=", "is64Bit", ";", "<BUGE>", "}", "~", "X86MCCodeEmitter", "(", ")", "{", "}", "static", "unsigned", "GetX86RegNum", "(", "const", "MCOperand", "&", "MO", ")", "{", "return", "X86RegisterInfo", "::", "getX86RegNum", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}" ]

[ "<FIXS>", "#", "include", "<STR_LIT>", "llvm/Support/raw_ostream.h", "<STR_LIT>", "<FIXE>", "<FIXS>", "BlackfinAsmPrinter", "(", "TargetMachine", "&", "TM", ",", "MCStreamer", "&", "Streamer", ")", ":", "AsmPrinter", "(", "TM", ",", "Streamer", ")", "{", "}", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "llvm/Target/TargetRegistry.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/ADT/SmallString.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/ErrorHandling.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "llvm/Support/FormattedStream.h", "<STR_LIT>", "<BUGE>", "using", "namespace", "llvm", ";", "namespace", "{", "class", "BlackfinAsmPrinter", ":", "public", "AsmPrinter", "{", "public", ":", "<BUGS>", "BlackfinAsmPrinter", "(", "formatted_raw_ostream", "&", "O", ",", "TargetMachine", "&", "TM", ",", "MCStreamer", "&", "Streamer", ")", ":", "AsmPrinter", "(", "O", ",", "TM", ",", "Streamer", ")", "{", "}", "<BUGE>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "<STR_LIT>", "Blackfin Assembly Printer", "<STR_LIT>", ";" ]

[ ")", ";" ]

[ "trick_no", "=", "try_constant_tricks", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "&", "x", ",", "&", "y", ")", ";", "gcc_assert", "(", "trick_no", "==", "<NUM_LIT>", ")", ";", "out_operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", ";", "out_operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "x", ")", ";", "out_operands", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", ";", "if", "(", "x", ">=", "<NUM_LIT>", "&&", "x", "<=", "<NUM_LIT>", ")", "load_op", "=", "<STR_LIT>", "movi\\t%0,%1", "<STR_LIT>", ";", "else", "if", "(", "(", "x", "&", "(", "x", "-", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", "load_op", "=", "<STR_LIT>", "bgeni\\t%0,%P1", "<STR_LIT>", ";", "else", "if", "(", "(", "x", "&", "(", "x", "+", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", "load_op", "=", "<STR_LIT>", "bmaski\\t%0,%N1", "<STR_LIT>", ";", "else", "load_op", "=", "<STR_LIT>", "BADMOVI\\t%0,%1", "<STR_LIT>", ";", "sprintf", "(", "buf", ",", "<STR_LIT>", "%s\\n\\tandn\\t%%2,%%0", "<STR_LIT>", ",", "load_op", ")", ";", "output_asm_insn", "(", "buf", ",", "out_operands" ]

[ "}" ]

[ "def", "i", ":", "AI3ldstidxT", "<", "op", ",", "<NUM_LIT>", ",", "(", "outs", "GPR", ":", "$", "base_wb", ")", ",", "(", "ins", "GPR", ":", "$", "Rt", ",", "addr_offset_none", ":", "$", "addr", ",", "postidx_imm8", ":", "$", "offset", ")", ",", "IndexModePost", ",", "StMiscFrm", ",", "IIC_iStore_bh_ru", ",", "opc", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

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

[ "def", "L2_loadrubgp", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "u32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_c4db48cb", ",", "TypeV2LDST", ">", ",", "Enc_25bef0", ",", "AddrModeRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "GP", "]", ";" ]

[ "_", "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmpeq_epi16", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "vec_cmpeq", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")" ]

[ "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";" ]

[ "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "MI", "->", "killsRegister", "(", "X86", "::", "EFLAGS", ")", "&&", "!", "checkAndUpdateEFLAGSKill", "(", "MI", ",", "BB", ",", "TRI", ")", ")", "{", "copy0MBB", "->", "addLiveIn", "(", "X86", "::", "EFLAGS", ")", ";", "sinkMBB", "->", "addLiveIn", "(", "X86", "::", "EFLAGS", ")", ";", "}", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "unsigned", "Opc", "=", "X86", "::", "GetCondBranchFromCond", "(", "(", "X86", "::", "CondCode", ")", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Opc", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ";", "copy0MBB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "*", "sinkMBB", ",", "sinkMBB", "->", "begin", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_loadu_pd", "(", "double", "const", "*", "_", "_", "P", ")", "{", "return", "*", "(", "_", "_", "m256d_u", "*", ")", "_", "_", "P", ";" ]

[ "[", "(", "set", "(", "reg", ":", "QI", "A_REGNUM", ")", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

[ "[", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "ashift", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "]", ")", ")", "]", "<STR_LIT>" ]

[ "<FIXS>", "field", "Operand", "ImmOpType", "=", "!", "if", "(", "!", "eq", "(", "vt", ".", "Size", ",", "<NUM_LIT>", ")", ",", "KImmFP32", ",", "KImmFP16", ")", ";", "<FIXE>" ]

[ "}", "class", "VOP_MADAK", "ValueType", "vt", ">", ":", "VOP_MADK_Base", "vt", ">", "{", "<BUGS>", "field", "Operand", "ImmOpType", "=", "!", "if", "(", "!", "eq", "(", "vt", ".", "Size", ",", "<NUM_LIT>", ")", ",", "f32kimm", ",", "f16kimm", ")", ";", "<BUGE>", "field", "dag", "Ins32", "=", "!", "if", "(", "!", "eq", "(", "vt", ".", "Size", ",", "<NUM_LIT>", ")", ",", "(", "ins", "VSrc_f32_Deferred", ":", "$", "src0", ",", "VGPR_32", ":", "$", "src1", ",", "ImmOpType", ":", "$", "imm", ")", ",", "(", "ins", "VSrc_f16_Deferred", ":", "$", "src0", ",", "VGPR_32", ":", "$", "src1", ",", "ImmOpType", ":", "$", "imm", ")", ")", ";" ]

[ "(", "unsigned", "AluOp", ")", "{" ]

[ "inline", "static", "unsigned", "encodeDLXAluCode" ]

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

[ "emit_insn", "(", "gen_floatsidf2_i", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[" ]

[ "<FIXS>", "def", "PPCretglue", ":", "SDNode", "<STR_LIT>", ",", "SDTNone", ",", "<FIXE>" ]

[ "[", "SDNPHasChain", ",", "SDNPOptInGlue", ",", "SDNPOutGlue", ",", "SDNPVariadic", "]", ">", ";", "<BUGS>", "def", "retglue", ":", "SDNode", "<STR_LIT>", ",", "SDTNone", ",", "<BUGE>", "[", "SDNPHasChain", ",", "SDNPOptInGlue", ",", "SDNPVariadic", "]", ">", ";", "def", "PPCtc_return", ":", "SDNode", "<STR_LIT>", ",", "SDT_PPCTC_ret", "," ]

[ "CPU", "=", "<STR_LIT>", "generic", "<STR_LIT>", ";" ]

[ "WebAssemblySubtarget", "&", "WebAssemblySubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "LLVM_DEBUG", "(", "llvm", "::", "dbgs", "(", ")", "<<", "<STR_LIT>", "initializeSubtargetDependencies\\n", "<STR_LIT>", ")", ";", "if", "(", "CPU", ".", "empty", "(", ")", ")" ]

[ "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";" ]

[ "if", "(", "sr", "->", "saved", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "x", ",", "insn", "=", "emit_insn", "(", "gen_pop", "(", "sr", "->", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";" ]

[ "TheGCNTarget", ")", ";" ]

[ "RegisterMCAsmParser", "<", "AMDGPUAsmParser", ">", "A", "(", "TheAMDGPUTarget", ")", ";", "RegisterMCAsmParser", "<", "AMDGPUAsmParser", ">", "B", "(" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "d30v_stack_t", "*", "d30v_stack_info", "(", ")", "{", "static", "d30v_stack_t", "info", ",", "zero_info", ";", "d30v_stack_t", "*", "info_ptr", "=", "&", "info", ";", "tree", "fndecl", "=", "current_function_decl", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "fndecl", ")", ";", "int", "varargs_p", "=", "<NUM_LIT>", ";", "tree", "cur_arg", ";", "tree", "next_arg", ";", "int", "saved_gprs", ";", "int", "saved_accs", ";", "int", "memrefs_2words", ";", "int", "memrefs_1word", ";", "unsigned", "char", "save_gpr_p", "[", "GPR_LAST", "]", ";", "int", "i", ";", "if", "(", "d30v_stack_cache", ")", "return", "d30v_stack_cache", ";", "info", "=", "zero_info", ";", "if", "(", "current_function_profile", ")", "regs_ever_live", "[", "GPR_LINK", "]", "=", "<NUM_LIT>", ";", "if", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "<NUM_LIT>", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", "varargs_p", "=", "<NUM_LIT>", ";", "else", "{", "for", "(", "cur_arg", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "cur_arg", "!=", "(", "tree", ")", "<NUM_LIT>", ";", "cur_arg", "=", "next_arg", ")", "{", "next_arg", "=", "TREE_CHAIN", "(", "cur_arg", ")", ";", "if", "(", "next_arg", "==", "(", "tree", ")", "<NUM_LIT>", ")", "{", "if", "(", "DECL_NAME", "(", "cur_arg", ")", "&&", "!", "strcmp", "(", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "cur_arg", ")", ")", ",", "<STR_LIT>", "__builtin_va_alist", "<STR_LIT>", ")", ")", "varargs_p", "=", "<NUM_LIT>", ";", "break", ";", "}", "}", "}", "saved_accs", "=", "<NUM_LIT>", ";", "memrefs_2words", "=", "<NUM_LIT>", ";", "memrefs_1word", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "ACCUM_FIRST", ";", "i", "<=", "ACCUM_LAST", ";", "i", "++", ")", "{", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "{", "info_ptr", "->", "save_p", "[", "i", "]", "=", "<NUM_LIT>", ";", "saved_accs", "++", ";", "memrefs_2words", "++", ";", "}", "}", "saved_gprs", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "GPR_FIRST", ";", "i", "<=", "GPR_LAST", ";", "i", "++", ")", "{", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "(", "!", "call_used_regs", "[", "i", "]", "||", "i", "==", "GPR_LINK", ")", ")", "{", "save_gpr_p", "[", "i", "]", "=", "<NUM_LIT>", ";", "saved_gprs", "++", ";", "}", "else", "save_gpr_p", "[", "i", "]", "=", "<NUM_LIT>", ";", "}", "for", "(", "i", "=", "GPR_FIRST", ";", "i", "<=", "GPR_LAST", ";", "i", "++", ")", "{", "if", "(", "(", "(", "i", "-", "GPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "save_gpr_p", "[", "i", "]", "&&", "save_gpr_p", "[", "i", "+", "<NUM_LIT>", "]", ")", "{", "memrefs_2words", "++", ";", "info_ptr", "->", "save_p", "[", "i", "++", "]", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "save_gpr_p", "[", "i", "]", ")", "{", "memrefs_1word", "++", ";", "info_ptr", "->", "save_p", "[", "i", "]", "=", "<NUM_LIT>", ";", "}", "}", "info_ptr", "->", "varargs_p", "=", "varargs_p", ";", "info_ptr", "->", "varargs_size", "=", "(", "(", "varargs_p", ")", "?", "(", "GPR_ARG_LAST", "+", "<NUM_LIT>", "-", "GPR_ARG_FIRST", ")", "*", "UNITS_PER_WORD", ":", "<NUM_LIT>", ")", ";", "info_ptr", "->", "accum_size", "=", "<NUM_LIT>", "*", "UNITS_PER_WORD", "*", "saved_accs", ";", "info_ptr", "->", "gpr_size", "=", "D30V_ALIGN", "(", "UNITS_PER_WORD", "*", "saved_gprs", ",", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", ";", "info_ptr", "->", "vars_size", "=", "D30V_ALIGN", "(", "get_frame_size", "(", ")", ",", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", ";", "info_ptr", "->", "parm_size", "=", "D30V_ALIGN", "(", "current_function_outgoing_args_size", ",", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", ";", "info_ptr", "->", "total_size", "=", "D30V_ALIGN", "(", "(", "info_ptr", "->", "gpr_size", "+", "info_ptr", "->", "accum_size", "+", "info_ptr", "->", "vars_size", "+", "info_ptr", "->", "parm_size", "+", "info_ptr", "->", "varargs_size", "+", "current_function_pretend_args_size", ")", ",", "(", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ")", ";", "info_ptr", "->", "save_offset", "=", "(", "info_ptr", "->", "total_size", "-", "(", "current_function_pretend_args_size", "+", "info_ptr", "->", "varargs_size", "+", "info_ptr", "->", "gpr_size", "+", "info_ptr", "->", "accum_size", ")", ")", ";", "info_ptr", "->", "link_offset", "=", "(", "info_ptr", "->", "total_size", "-", "(", "current_function_pretend_args_size", "+", "info_ptr", "->", "varargs_size", "+", "(", "info_ptr", "->", "gpr_size", "-", "UNITS_PER_WORD", "*", "saved_gprs", ")", "+", "UNITS_PER_WORD", ")", ")", ";", "info_ptr", "->", "memrefs_varargs", "=", "info_ptr", "->", "varargs_size", "/", "(", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", ";", "info_ptr", "->", "memrefs_2words", "=", "memrefs_2words", ";", "info_ptr", "->", "memrefs_1word", "=", "memrefs_1word", ";", "if", "(", "reload_completed", ")", "d30v_stack_cache", "=", "info_ptr", ";", "return", "info_ptr", ";", "}" ]

[ "Calculate", "the", "stack", "information", "for", "the", "current", "function", ".", "D30V", "stack", "frames", "look", "like", ":", "high", "|", "....", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "Argument", "word", "#", "19", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "Argument", "word", "#", "18", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "Argument", "word", "#", "17", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "Argument", "word", "#", "16", "|", "Prev", "sp", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "|", "|", "Save", "for", "arguments", "1", "..", "16", "if", "|", "|", "the", "func", ".", "uses", "stdarg/varargs", "|", "|", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "|", "|", "Save", "area", "for", "GPR", "registers", "|", "|", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "|", "|", "Save", "area", "for", "accumulators", "|", "|", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "|", "|", "Local", "variables", "|", "|", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "|", "|", "alloca", "space", "if", "used", "|", "|", "|", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+", "|", "|", "|", "Space", "for", "outgoing", "arguments", "|", "|", "|", "low", "SP", "--", "--", ">", "+", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-+" ]

[ "<STR_LIT>", ";" ]

[ "def", "MemoryIndexed16Operand", ":", "AsmOperandClass", "{", "let", "Name", "=" ]

[ "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "CommentStream", ")", "HasCustomInstComment", "=", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "MII", ")", ";", "printInstFlags", "(", "MI", ",", "OS", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode64Bit", "]", ")", ")", "{", "OS", "<<", "<STR_LIT>", "\\tcallq\\t", "<STR_LIT>", ";", "printPCRelImm", "(", "MI", ",", "<NUM_LIT>", ",", "OS", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", "{", "OS", "<<", "<STR_LIT>", "\\tdata32", "<STR_LIT>", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", "&&", "!", "printVecCompareInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "W", ",", "(", "_", "_", "mmask32", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_psllwi512_mask", "(", "(", "_", "_", "v32hi", ")", "_", "_", "A", ",", "_", "_", "B", ",", "(", "_", "_", "v32hi", ")", "_", "_" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<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", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "const", "VEMCExpr", "*", "expr", "=", "VEMCExpr", "::", "create", "(", "Kind", ",", "GOT", ",", "OutContext", ")", ";", "return", "MCOperand", "::", "createExpr", "(", "expr", ")", ";" ]

[ "}" ]

[ "def", "FRAMEri", ":", "Operand", "<", "iPTR", ">", "{", "let", "MIOperandInfo", "=", "(", "ops", "R600_Reg32", ":", "$", "ptr", ",", "i32imm", ":", "$", "index", ")", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "HI" ]

[ "Cond", ",", "MVT", "::", "i1", ")", ";" ]

[ "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "if", "(", "CC", "==", "ISD", "::", "SETEQ", "||", "CC", "==", "ISD", "::", "SETNE", ")", "return", "SDValue", "(", ")", ";", "}", "bool", "OV", ";", "APInt", "Diff", "=", "TrueVal", ".", "ssub_ov", "(", "FalseVal", ",", "OV", ")", ";", "if", "(", "OV", ")", "return", "SDValue", "(", ")", ";", "APInt", "AbsDiff", "=", "Diff", ".", "abs", "(", ")", ";", "if", "(", "AbsDiff", ".", "isPowerOf2", "(", ")", "||", "(", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", ")", "&&", "(", "AbsDiff", "==", "<NUM_LIT>", "||", "AbsDiff", "==", "<NUM_LIT>", "||", "AbsDiff", "==", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "TrueVal", ".", "slt", "(", "FalseVal", ")", ")", "{", "Cond", "=", "DAG", ".", "getNOT", "(", "DL", "," ]

[ "}" ]

[ "class", "Enc_b388cf", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "II", ";", "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>", ">", "Rs32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "let", "Uses", "=", "[", "CS", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "for", "(", "User", "*", "U", ":", "Intrin", "->", "users", "(", ")", ")", "{", "CallInst", "*", "CI", "=", "cast", "<", "CallInst", ">", "(", "U", ")", ";", "Function", "*", "CallingFunction", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "SeenFuncs", ".", "insert", "(", "CallingFunction", ")", ".", "second", ")", "CallingFunction", "->", "addFnAttr", "(", "AttrName", ")", ";" ]

[ ")", ")" ]

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

[ "}" ]

[ "OpUsefulBits", "<<=", "OpUsefulBits", ".", "getBitWidth", "(", ")", "-", "Imm", ";", "getUsefulBits", "(", "Op", ",", "OpUsefulBits", ",", "Depth", "+", "<NUM_LIT>", ")", ";", "OpUsefulBits", ".", "lshrInPlace", "(", "OpUsefulBits", ".", "getBitWidth", "(", ")", "-", "Imm", ")", ";", "}", "UsefulBits", "&=", "OpUsefulBits", ";" ]

[ "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "bool", "aarch64_gen_adjusted_ldpstp", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "scalar_mode", "mode", ",", "RTX_CODE", "code", ")", "{", "rtx", "base", ",", "offset_1", ",", "offset_3", ",", "t1", ",", "t2", ";", "rtx", "mem_1", ",", "mem_2", ",", "mem_3", ",", "mem_4", ";", "rtx", "temp_operands", "[", "<NUM_LIT>", "]", ";", "HOST_WIDE_INT", "off_val_1", ",", "off_val_3", ",", "base_off", ",", "new", "_", "off_1", ",", "new", "_", "off_3", ",", "stp_off_upper_limit", ",", "stp_off_lower_limit", ",", "msize", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "temp_operands", "[", "i", "]", "=", "operands", "[", "i", "]", ";", "qsort", "(", "temp_operands", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "*", "sizeof", "(", "rtx", "*", ")", ",", "aarch64_ldrstr_offset_compare", ")", ";", "if", "(", "load", ")", "{", "mem_1", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "mem_2", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "mem_3", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "mem_4", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "mem_1", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "mem_2", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "mem_3", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "mem_4", "=", "copy_rtx", "(", "temp_operands", "[", "<NUM_LIT>", "]", ")", ";", "gcc_assert", "(", "code", "==", "UNKNOWN", ")", ";", "}", "extract_base_offset_in_addr", "(", "mem_1", ",", "&", "base", ",", "&", "offset_1", ")", ";", "extract_base_offset_in_addr", "(", "mem_3", ",", "&", "base", ",", "&", "offset_3", ")", ";", "gcc_assert", "(", "base", "!=", "NULL_RTX", "&&", "offset_1", "!=", "NULL_RTX", "&&", "offset_3", "!=", "NULL_RTX", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "stp_off_upper_limit", "=", "msize", "*", "(", "<NUM_LIT>", "-", "<NUM_LIT>", ")", ";", "stp_off_lower_limit", "=", "-", "msize", "*", "<NUM_LIT>", ";", "off_val_1", "=", "INTVAL", "(", "offset_1", ")", ";", "off_val_3", "=", "INTVAL", "(", "offset_3", ")", ";", "if", "(", "msize", "<=", "<NUM_LIT>", ")", "base_off", "=", "(", "off_val_1", "+", "off_val_3", ")", "/", "<NUM_LIT>", ";", "else", "base_off", "=", "off_val_1", ";", "if", "(", "base_off", "%", "msize", "!=", "off_val_1", "%", "msize", ")", "base_off", "+=", "(", "(", "(", "base_off", "%", "msize", ")", "-", "(", "off_val_1", "%", "msize", ")", ")", "+", "msize", ")", "%", "msize", ";", "else", "if", "(", "msize", "<=", "<NUM_LIT>", ")", "base_off", "+=", "msize", ";", "if", "(", "base_off", ">=", "<NUM_LIT>", ")", "{", "base_off", "=", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "base_off", "-=", "(", "(", "(", "base_off", "%", "msize", ")", "-", "(", "off_val_1", "%", "msize", ")", ")", "+", "msize", ")", "%", "msize", ";", "}", "if", "(", "base_off", "<=", "-", "<NUM_LIT>", ")", "{", "base_off", "=", "-", "<NUM_LIT>", "+", "<NUM_LIT>", ";", "base_off", "+=", "(", "(", "(", "base_off", "%", "msize", ")", "-", "(", "off_val_1", "%", "msize", ")", ")", "+", "msize", ")", "%", "msize", ";", "}", "new", "_", "off_1", "=", "off_val_1", "-", "base_off", ";", "new", "_", "off_3", "=", "off_val_3", "-", "base_off", ";", "if", "(", "new", "_", "off_1", ">", "stp_off_upper_limit", "||", "new", "_", "off_1", "<", "stp_off_lower_limit", "||", "new", "_", "off_3", ">", "stp_off_upper_limit", "||", "new", "_", "off_3", "<", "stp_off_lower_limit", ")", "return", "false", ";", "replace_equiv_address_nv", "(", "mem_1", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_1", ")", ",", "true", ")", ";", "replace_equiv_address_nv", "(", "mem_2", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_1", "+", "msize", ")", ",", "true", ")", ";", "replace_equiv_address_nv", "(", "mem_3", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_3", ")", ",", "true", ")", ";", "replace_equiv_address_nv", "(", "mem_4", ",", "plus_constant", "(", "Pmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "new", "_", "off_3", "+", "msize", ")", ",", "true", ")", ";", "if", "(", "!", "aarch64_mem_pair_operand", "(", "mem_1", ",", "mode", ")", "||", "!", "aarch64_mem_pair_operand", "(", "mem_3", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "code", "==", "ZERO_EXTEND", ")", "{", "mem_1", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_1", ")", ";", "mem_2", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_2", ")", ";", "mem_3", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_3", ")", ";", "mem_4", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mem_4", ")", ";", "}", "else", "if", "(", "code", "==", "SIGN_EXTEND", ")", "{", "mem_1", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_1", ")", ";", "mem_2", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_2", ")", ";", "mem_3", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_3", ")", ";", "mem_4", "=", "gen_rtx_SIGN_EXTEND", "(", "DImode", ",", "mem_4", ")", ";", "}", "if", "(", "load", ")", "{", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_1", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_2", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_3", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_4", ";", "}", "else", "{", "operands", "[", "<NUM_LIT>", "]", "=", "mem_1", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_2", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_3", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "mem_4", ";", "operands", "[", "<NUM_LIT>", "]", "=", "temp_operands", "[", "<NUM_LIT>", "]", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "plus_constant", "(", "DImode", ",", "base", ",", "base_off", ")", ")", ")", ";", "t1", "=", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "t2", "=", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "t1", ",", "t2", ")", ")", ")", ";", "t1", "=", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "t2", "=", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "t1", ",", "t2", ")", ")", ")", ";", "return", "true", ";", "}" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", ",", "this", "function", "pairs", "them", "into", "ldp/stp", "after", "adjusting", "the", "offset", ".", "It", "depends", "on", "the", "fact", "that", "addresses", "of", "load/store", "instructions", "are", "in", "increasing", "order", ".", "MODE", "is", "the", "mode", "of", "memory", "operands", ".", "CODE", "is", "the", "rtl", "operator", "which", "should", "be", "applied", "to", "all", "memory", "operands", ",", "it", "'s", "SIGN_EXTEND", ",", "ZERO_EXTEND", "or", "UNKNOWN", "." ]

[ ")", "-", "<NUM_LIT>", ";" ]

[ "unsigned", "ARMMCCodeEmitter", "::", "getBitfieldInvertedMaskOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "Op", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "Op", ")", ";", "uint32_t", "v", "=", "~", "MO", ".", "getImm", "(", ")", ";", "uint32_t", "lsb", "=", "countTrailingZeros", "(", "v", ")", ";", "uint32_t", "msb", "=", "(", "<NUM_LIT>", "-", "countLeadingZeros", "(", "v", ")" ]

[ "}" ]

[ "static", "inline", "unsigned", "getArithShiftValue", "(", "unsigned", "Imm", ")", "{", "return", "Imm", "&", "<NUM_LIT>", ";" ]

[ "}" ]

[ "_", "_", "arm_vfmasq_n_f32", "(", "float32x4_t", "_", "_", "a", ",", "float32x4_t", "_", "_", "b", ",", "float32_t", "_", "_", "c", ")", "{", "return", "_", "_", "builtin_mve_vfmasq_n_fv4sf", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "case", "fixup_Hexagon_TPREL_HI16", ":" ]

[ "case", "fixup_Hexagon_32_6_X", ":", "return", "ELF", "::", "R_HEX_32_6_X", ";", "case", "fixup_Hexagon_B22_PCREL_X", ":", "return", "ELF", "::", "R_HEX_B22_PCREL_X", ";", "case", "fixup_Hexagon_B15_PCREL_X", ":", "return", "ELF", "::", "R_HEX_B15_PCREL_X", ";", "case", "fixup_Hexagon_B13_PCREL_X", ":", "return", "ELF", "::", "R_HEX_B13_PCREL_X", ";", "case", "fixup_Hexagon_B9_PCREL_X", ":", "return", "ELF", "::", "R_HEX_B9_PCREL_X", ";", "case", "fixup_Hexagon_B7_PCREL_X", ":", "return", "ELF", "::", "R_HEX_B7_PCREL_X", ";", "case", "fixup_Hexagon_16_X", ":", "return", "ELF", "::", "R_HEX_16_X", ";", "case", "fixup_Hexagon_12_X", ":", "return", "ELF", "::", "R_HEX_12_X", ";", "case", "fixup_Hexagon_11_X", ":", "return", "ELF", "::", "R_HEX_11_X", ";", "case", "fixup_Hexagon_10_X", ":", "return", "ELF", "::", "R_HEX_10_X", ";", "case", "fixup_Hexagon_9_X", ":", "return", "ELF", "::", "R_HEX_9_X", ";", "case", "fixup_Hexagon_8_X", ":", "return", "ELF", "::", "R_HEX_8_X", ";", "case", "fixup_Hexagon_7_X", ":", "return", "ELF", "::", "R_HEX_7_X", ";", "case", "fixup_Hexagon_6_X", ":", "return", "ELF", "::", "R_HEX_6_X", ";", "case", "fixup_Hexagon_32_PCREL", ":", "return", "ELF", "::", "R_HEX_32_PCREL", ";", "case", "fixup_Hexagon_COPY", ":", "return", "ELF", "::", "R_HEX_COPY", ";", "case", "fixup_Hexagon_GLOB_DAT", ":", "return", "ELF", "::", "R_HEX_GLOB_DAT", ";", "case", "fixup_Hexagon_JMP_SLOT", ":", "return", "ELF", "::", "R_HEX_JMP_SLOT", ";", "case", "fixup_Hexagon_RELATIVE", ":", "return", "ELF", "::", "R_HEX_RELATIVE", ";", "case", "fixup_Hexagon_PLT_B22_PCREL", ":", "return", "ELF", "::", "R_HEX_PLT_B22_PCREL", ";", "case", "fixup_Hexagon_GOTREL_LO16", ":", "return", "ELF", "::", "R_HEX_GOTREL_LO16", ";", "case", "fixup_Hexagon_GOTREL_HI16", ":", "return", "ELF", "::", "R_HEX_GOTREL_HI16", ";", "case", "fixup_Hexagon_GOTREL_32", ":", "return", "ELF", "::", "R_HEX_GOTREL_32", ";", "case", "fixup_Hexagon_GOT_LO16", ":", "return", "ELF", "::", "R_HEX_GOT_LO16", ";", "case", "fixup_Hexagon_GOT_HI16", ":", "return", "ELF", "::", "R_HEX_GOT_HI16", ";", "case", "fixup_Hexagon_GOT_32", ":", "return", "ELF", "::", "R_HEX_GOT_32", ";", "case", "fixup_Hexagon_GOT_16", ":", "return", "ELF", "::", "R_HEX_GOT_16", ";", "case", "fixup_Hexagon_DTPMOD_32", ":", "return", "ELF", "::", "R_HEX_DTPMOD_32", ";", "case", "fixup_Hexagon_DTPREL_LO16", ":", "return", "ELF", "::", "R_HEX_DTPREL_LO16", ";", "case", "fixup_Hexagon_DTPREL_HI16", ":", "return", "ELF", "::", "R_HEX_DTPREL_HI16", ";", "case", "fixup_Hexagon_DTPREL_32", ":", "return", "ELF", "::", "R_HEX_DTPREL_32", ";", "case", "fixup_Hexagon_DTPREL_16", ":", "return", "ELF", "::", "R_HEX_DTPREL_16", ";", "case", "fixup_Hexagon_GD_PLT_B22_PCREL", ":", "return", "ELF", "::", "R_HEX_GD_PLT_B22_PCREL", ";", "case", "fixup_Hexagon_LD_PLT_B22_PCREL", ":", "return", "ELF", "::", "R_HEX_LD_PLT_B22_PCREL", ";", "case", "fixup_Hexagon_GD_GOT_LO16", ":", "return", "ELF", "::", "R_HEX_GD_GOT_LO16", ";", "case", "fixup_Hexagon_GD_GOT_HI16", ":", "return", "ELF", "::", "R_HEX_GD_GOT_HI16", ";", "case", "fixup_Hexagon_GD_GOT_32", ":", "return", "ELF", "::", "R_HEX_GD_GOT_32", ";", "case", "fixup_Hexagon_GD_GOT_16", ":", "return", "ELF", "::", "R_HEX_GD_GOT_16", ";", "case", "fixup_Hexagon_LD_GOT_LO16", ":", "return", "ELF", "::", "R_HEX_LD_GOT_LO16", ";", "case", "fixup_Hexagon_LD_GOT_HI16", ":", "return", "ELF", "::", "R_HEX_LD_GOT_HI16", ";", "case", "fixup_Hexagon_LD_GOT_32", ":", "return", "ELF", "::", "R_HEX_LD_GOT_32", ";", "case", "fixup_Hexagon_LD_GOT_16", ":", "return", "ELF", "::", "R_HEX_LD_GOT_16", ";", "case", "fixup_Hexagon_IE_LO16", ":", "return", "ELF", "::", "R_HEX_IE_LO16", ";", "case", "fixup_Hexagon_IE_HI16", ":", "return", "ELF", "::", "R_HEX_IE_HI16", ";", "case", "fixup_Hexagon_IE_32", ":", "return", "ELF", "::", "R_HEX_IE_32", ";", "case", "fixup_Hexagon_IE_GOT_LO16", ":", "return", "ELF", "::", "R_HEX_IE_GOT_LO16", ";", "case", "fixup_Hexagon_IE_GOT_HI16", ":", "return", "ELF", "::", "R_HEX_IE_GOT_HI16", ";", "case", "fixup_Hexagon_IE_GOT_32", ":", "return", "ELF", "::", "R_HEX_IE_GOT_32", ";", "case", "fixup_Hexagon_IE_GOT_16", ":", "return", "ELF", "::", "R_HEX_IE_GOT_16", ";", "case", "fixup_Hexagon_TPREL_LO16", ":", "return", "ELF", "::", "R_HEX_TPREL_LO16", ";" ]

[ "false", ";" ]

[ "const", "DebugLoc", "&", "DbgLoc", "=", "I", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "getLoadStoreOp", "(", "DstTy", ",", "RegBank", ",", "TargetOpcode", "::", "G_LOAD", ",", "Alignment", ")", ";", "const", "ConstantFP", "*", "CFP", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getFPImm", "(", ")", ";", "unsigned", "CPI", "=", "MF", ".", "getConstantPool", "(", ")", "->", "getConstantPoolIndex", "(", "CFP", ",", "Alignment", ")", ";", "MachineInstr", "*", "LoadInst", "=", "nullptr", ";", "unsigned", "char", "OpFlag", "=", "STI", ".", "classifyLocalReference", "(", "nullptr", ")", ";", "if", "(", "CM", "==", "CodeModel", "::", "Large", "&&", "STI", ".", "is64Bit", "(", ")", ")", "{", "Register", "AddrReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "X86", "::", "GR64RegClass", ")", ";", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "I", ",", "DbgLoc", ",", "TII", ".", "get", "(", "X86", "::", "MOV64ri", ")", ",", "AddrReg", ")", ".", "addConstantPoolIndex", "(", "CPI", ",", "<NUM_LIT>", ",", "OpFlag", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getConstantPool", "(", "MF", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "LLT", "::", "pointer", "(", "<NUM_LIT>", ",", "MF", ".", "getDataLayout", "(", ")", ".", "getPointerSizeInBits", "(", ")", ")", ",", "Alignment", ")", ";", "LoadInst", "=", "addDirectMem", "(", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "I", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "DstReg", ")", ",", "AddrReg", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "CM", "==", "CodeModel", "::", "Small", "||", "!", "STI", ".", "is64Bit", "(", ")", ")", "{", "unsigned", "PICBase", "=", "<NUM_LIT>", ";", "if", "(", "OpFlag", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "OpFlag", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "return" ]

[ "MatchOperand_Success", ";" ]

[ "do", "{", "if", "(", "parseCnt", "(", "Waitcnt", ")", ")", "return", "MatchOperand_ParseFail", ";", "}", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", ";", "break", ";", "}", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "this", ",", "Waitcnt", ",", "S", ")", ")", ";", "return" ]

[ "}" ]

[ "let", "ParserMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

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

[ "assert", "(", "PrologueBB", ")", ";", "IRBuilder", "<", ">", "IRB", "(", "&", "PrologueBB", "->", "front", "(", ")", ")", ";", "Function", "*", "IRG_SP", "=", "Intrinsic", "::", "getDeclaration", "(", "F", "->", "getParent", "(", ")", ",", "Intrinsic", "::", "aarch64_irg_sp", ")", ";", "Instruction", "*", "Base", "=", "IRB", ".", "CreateCall", "(", "IRG_SP", ",", "{", "Constant", "::", "getNullValue", "(", "IRB", ".", "getInt64Ty", "(", ")", ")", "}", ")", ";", "Base", "->", "setName", "(" ]

[ "return", "AbsImm", ">=", "<NUM_LIT>", "&&", "AbsImm", "<=", "<NUM_LIT>", ";" ]

[ "bool", "ARMTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "int64_t", "AbsImm", "=", "std", "::", "abs", "(", "Imm", ")", ";", "if", "(", "!", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "AbsImm", ")", "!=", "-", "<NUM_LIT>", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "AbsImm", ")", "!=", "-", "<NUM_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "pc", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "<FIXS>", "(", "define_int_iterator", "AESDECENCKL", "[", "UNSPECV_AESDEC128KLU8", "UNSPECV_AESDEC256KLU8UNSPECV_AESENC128KLU8", "UNSPECV_AESENC256KLU8", "]", ")", "<FIXE>", "<FIXS>", "(", "define_int_attr", "aesklvariant", "[", "(", "UNSPECV_AESDEC128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESDEC256KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENC128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENC256KLU8", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "V2DI", "[", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "AESDECENCKL", ")", ")", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "CCZ", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "AESDECENCKL", ")", ")", "]", "<FIXE>", "<FIXS>", "(", "define_int_iterator", "AESDECENCWIDEKL", "[", "UNSPECV_AESDECWIDE128KLU8", "UNSPECV_AESDECWIDE256KLU8UNSPECV_AESENCWIDE128KLU8", "UNSPECV_AESENCWIDE256KLU8", "]", ")", "<FIXE>", "<FIXS>", "(", "define_int_attr", "aeswideklvariant", "[", "(", "UNSPECV_AESDECWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESDECWIDE256KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE256KLU8", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "define_int_attr", "AESWIDEKLVARIANT", "[", "(", "UNSPECV_AESDECWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESDECWIDE256KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE256KLU8", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_int_iterator", "AESDECENCKL", "[", "UNSPECV_AESDEC128KLU8", "UNSPECV_AESDEC256KLU8UNSPECV_AESENC128KLU8", "UNSPECV_AESENC256KLU8", "]", ")", "<BUGE>", "<BUGS>", "(", "define_int_attr", "aesklvariant", "[", "(", "UNSPECV_AESDEC128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESDEC256KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENC128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENC256KLU8", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "unspec_volatile", ":", "V2DI", "[", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "AESDECENCKL", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "CCZ", "FLAGS_REG", ")", "<BUGS>", "(", "unspec_volatile", ":", "CCZ", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "AESDECENCKL", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_int_iterator", "AESDECENCWIDEKL", "[", "UNSPECV_AESDECWIDE128KLU8", "UNSPECV_AESDECWIDE256KLU8UNSPECV_AESENCWIDE128KLU8", "UNSPECV_AESENCWIDE256KLU8", "]", ")", "<BUGE>", "<BUGS>", "(", "define_int_attr", "aeswideklvariant", "[", "(", "UNSPECV_AESDECWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESDECWIDE256KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE256KLU8", "<STR_LIT>", ")", "]", ")", "<BUGE>", "<BUGS>", "(", "define_int_attr", "AESWIDEKLVARIANT", "[", "(", "UNSPECV_AESDECWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESDECWIDE256KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE128KLU8", "<STR_LIT>", ")", "(", "UNSPECV_AESENCWIDE256KLU8", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "match_par_dup", "<NUM_LIT>" ]

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

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

[ "[", "i", "]", ";" ]

[ "tree", "function_resolver", "::", "get_argument_type", "(", "unsigned", "int", "i", ")", "{", "tree", "arg", "=", "m_arglist" ]

[ ";" ]

[ "class", "InstRIEb", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "InstSystemZ", "<", "<NUM_LIT>", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "R1", ";", "bits", "<", "<NUM_LIT>", ">", "R2" ]

[ ")", ")" ]

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

[ "<STR_LIT>", ")" ]

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

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

[ "if", "(", "!", "SelectOff", "(", "N", ",", "Reg", ",", "Off", ")", ")", "{", "return", "false", ";", "}", "return", "isa", "<", "FrameIndexSDNode", ">" ]

[ "(", "L", ")", "{", "}" ]

[ "HexagonVectorLoopCarriedReuse", "(", "Loop", "*", "L", ")", ":", "CurLoop" ]

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

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

[ "<NUM_LIT>", ",", "<NUM_LIT>", ",", "shr_imm16", ">", "{" ]

[ "def", "MVE_VSHRNi32bh", ":", "MVE_VxSHRN", "<", "<STR_LIT>", ",", "<STR_LIT>", "," ]

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

[ "bool", "HexagonHardwareLoops", "::", "or", "derBumpCompare", "(", "MachineInstr", "*", "BumpI", ",", "MachineInstr", "*", "CmpI", ")", "{", "assert", "(", "BumpI", "!=", "CmpI", "&&", "<STR_LIT>", "Bump and compare in the same instruction?", "<STR_LIT>", ")", ";", "MachineBasicBlock", "*", "BB", "=", "BumpI", "->", "getParent", "(", ")", ";", "if", "(", "CmpI", "->", "getParent", "(", ")", "!=", "BB", ")", "return", "false", ";", "using", "instr_iterator", "=", "MachineBasicBlock", "::", "instr_iterator", ";", "for", "(", "instr_iterator", "I", "(", "BumpI", ")", ",", "E", "=", "BB", "->", "instr_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "&", "*", "I", "==", "CmpI", ")", "return", "true", ";", "Register", "PredR", "=", "CmpI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "bool", "FoundBump", "=", "false", ";", "instr_iterator", "CmpIt", "=", "CmpI", "->", "getIterator", "(", ")", ",", "NextIt", "=", "std", "::", "next", "(", "CmpIt", ")", ";", "for", "(", "instr_iterator", "I", "=", "NextIt", ",", "E", "=", "BB", "->", "instr_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "In", "=", "&", "*", "I", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "n", "=", "In", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "In", "->", "getOperand" ]

[ "unsigned", "FirstReg", "=", "FirstRegs", "[", "NumRegs", "-", "<NUM_LIT>", "]", ";" ]

[ "void", "addVectorList64Operands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "static", "unsigned", "FirstRegs", "[", "]", "=", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ";" ]

[ "return", "result", ";" ]

[ "int64_t", "result", ";", "_", "_", "asm__", "(", "<STR_LIT>", "saddlv %d0,%1.4s", "<STR_LIT>", ":", "<STR_LIT>", "=w", "<STR_LIT>", "(", "result", ")", ":", "<STR_LIT>", "w", "<STR_LIT>", "(", "a", ")", ":", ")", ";" ]

[ ")" ]

[ "force_reg", "(", "V2HFmode", ",", "operands", "[", "<NUM_LIT>", "]", ")", ",", "V2HFmode", ")", "emit_insn", "(", "gen_avx512fp16_fix", "<", "fixunssuffix", ">", "_truncv2di2", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "HImode", ")" ]

[ "{", "rtx", "addr", "if", "(", "operands", "[", "<NUM_LIT>", "]", "!", "=", "const0_rtx", ")", "FAIL", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "addr", ")", "operands", "[", "<NUM_LIT>", "]", "=", "addr" ]

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

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

[ "}" ]

[ "MCInst", "AArch64BranchTargetAligner", "::", "createNopInstruction", "(", ")", "{", "MCInst", "Inst", ";", "Inst", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "Inst", ";" ]

[ "}" ]

[ "def", "C2_cmpgei", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s8_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56f114f4", ",", "TypeALU32_2op", ">", "{", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_fmsub_pd", "(", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "B", ",", "_", "_", "m512d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmsubpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "<FIXS>", "(", "selectcc", "i32", ":", "$", "src0", ",", "-", "<NUM_LIT>", ",", "i32", ":", "$", "src1", ",", "i32", ":", "$", "src2", ",", "COND_SGT", ")", ",", "<FIXE>" ]

[ "def", ":", "Pat", "<BUGS>", "(", "selectcc", "i32", ":", "$", "src0", ",", "-", "<NUM_LIT>", ",", "i32", ":", "$", "src1", ",", "i32", ":", "$", "src2", ",", "COND_GT", ")", ",", "<BUGE>", "(", "CNDGE_INT", "$", "src0", ",", "$", "src1", ",", "$", "src2", ")", ">", ";" ]