Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "truncate", ":", "DI", "(", "match_operator", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

[ "<FIXS>", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "Addr", "+", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "<FIXE>" ]

[ "return", "I", ";", "}", "void", "CounterPropagateAddr", "(", "MachineInstr", "*", "MI", ",", "unsigned", "Addr", ")", "const", "{", "<BUGS>", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "WHILE_LOOP", ":", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "Addr", "+", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "Addr", ")", ";", "break", ";", "}", "<BUGE>", "}", "void", "CounterPropagateAddr", "(", "std", "::", "set", "MachineInstr", "*", ">", "MIs", ",", "unsigned", "Addr", ")", "const", "{" ]

[ "(", "ashift", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "GPI", "(", "lshiftrt", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "}" ]

[ "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "auto", "MIB", "=", "TII", "->", "buildDefaultInstruction", "(", "*", "BB", ",", "MI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int", "Idx", "=", "TII", "->", "getOperandIdx", "(", "*", "MIB", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "literal", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MIB", "->", "getOperand", "(", "Idx", ")", ".", "ChangeToGA", "(", "MO", ".", "getGlobal", "(", ")", ",", "MO", ".", "getOffset", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "MachineInstr", "*", "NewMI", "=", "TII", "->", "buildDefaultInstruction", "(", "*", "BB", ",", "MI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "TII", "->", "setImmOperand", "(", "*", "NewMI", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "src0_sel", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "isEOP", "(", "I", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "isEOP", "(", "I", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "MachineInstr", "*", "NewMI", "=", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "TII", "->", "addFlag", "(", "*", "NewMI", ",", "<NUM_LIT>", ",", "MO_FLAG_PUSH", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "MachineInstr", "*", "NewMI", "=", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "TII", "->", "addFlag", "(", "*", "NewMI", ",", "<NUM_LIT>", ",", "MO_FLAG_PUSH", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "BB", "->", "findDebugLoc", "(", "I", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegState", "::", "Kill", ")", ";", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "bool", "isLastInstructionOfItsType", "=", "true", ";", "unsigned", "InstExportType", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "NextExportInst", "=", "std", "::", "next", "(", "I", ")", ",", "EndBlock", "=", "BB", "->", "end", "(", ")", ";", "NextExportInst", "!=", "EndBlock", ";", "NextExportInst", "=", "std", "::", "next", "(", "NextExportInst", ")", ")", "{", "if", "(", "NextExportInst", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "NextExportInst", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "CurrentInstExportType", "=", "NextExportInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "CurrentInstExportType", "==", "InstExportType", ")", "{", "isLastInstructionOfItsType", "=", "false", ";", "break", ";", "}" ]

[ "MRI", ".", "setRegClass", "(", "DstReg", ",", "TRI", "->", "getEquivalentSGPRClass", "(", "MRI", ".", "getRegClass", "(", "DstReg", ")", ")", ")", ";" ]

[ "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "SrcReg", ")", "||", "!", "Register", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "return", "false", ";", "for", "(", "const", "auto", "&", "MO", ":", "MRI", ".", "reg_nodbg_operands", "(", "DstReg", ")", ")", "{", "const", "auto", "*", "UseMI", "=", "MO", ".", "getParent", "(", ")", ";", "if", "(", "UseMI", "==", "&", "MI", ")", "continue", ";", "if", "(", "MO", ".", "isDef", "(", ")", "||", "UseMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", "||", "UseMI", "->", "getOpcode", "(", ")", "<=", "TargetOpcode", "::", "GENERIC_OP_END", "||", "!", "TII", "->", "isOperandLegal", "(", "*", "UseMI", ",", "UseMI", "->", "getOperandNo", "(", "&", "MO", ")", ",", "&", "Src", ")", ")", "return", "false", ";", "}" ]

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

[ "def", "A4_pasrhtnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_1ae57e39", ",", "TypeALU32_2op", ">", ",", "Enc_fb6577", ",", "PredNewRel", "{", "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", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits" ]

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

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

[ "<NUM_LIT>", ";" ]

[ "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=" ]

[ "(", "_", "_", "v4di", ")", "_", "mm256_setzero_si256", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_prolvq256_mask", "(", "(", "_", "_", "v4di", ")", "_", "_", "A", ",", "(", "_", "_", "v4di", ")", "_", "_", "B", "," ]

[ "break", ";" ]

[ "}", "else", "if", "(", "(", "c", "==", "ITANIUM_CLASS_LD", "||", "c", "==", "ITANIUM_CLASS_FLD", "||", "c", "==", "ITANIUM_CLASS_FLDP", ")", "&&", "ia64_ld_address_bypass_p", "(", "insn", ",", "next", ")", ")", "{", "has_mem_op_consumer_p", "=", "true", ";" ]

[ "bool", "AArch64AsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "StringSwitch", "<", "StringRef", ">", "(", "Name", ".", "lower", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "beq", "<STR_LIT>", ",", "<STR_LIT>", "b.eq", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bne", "<STR_LIT>", ",", "<STR_LIT>", "b.ne", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bhs", "<STR_LIT>", ",", "<STR_LIT>", "b.hs", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bcs", "<STR_LIT>", ",", "<STR_LIT>", "b.cs", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "blo", "<STR_LIT>", ",", "<STR_LIT>", "b.lo", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bcc", "<STR_LIT>", ",", "<STR_LIT>", "b.cc", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bmi", "<STR_LIT>", ",", "<STR_LIT>", "b.mi", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bpl", "<STR_LIT>", ",", "<STR_LIT>", "b.pl", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bvs", "<STR_LIT>", ",", "<STR_LIT>", "b.vs", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bvc", "<STR_LIT>", ",", "<STR_LIT>", "b.vc", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bhi", "<STR_LIT>", ",", "<STR_LIT>", "b.hi", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bls", "<STR_LIT>", ",", "<STR_LIT>", "b.ls", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bge", "<STR_LIT>", ",", "<STR_LIT>", "b.ge", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "blt", "<STR_LIT>", ",", "<STR_LIT>", "b.lt", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bgt", "<STR_LIT>", ",", "<STR_LIT>", "b.gt", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "ble", "<STR_LIT>", ",", "<STR_LIT>", "b.le", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bal", "<STR_LIT>", ",", "<STR_LIT>", "b.al", "<STR_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "bnv", "<STR_LIT>", ",", "<STR_LIT>", "b.nv", "<STR_LIT>", ")", ".", "Default", "(", "Name", ")", ";", "if", "(", "getTok", "(", ")", ".", "is", "(", "AsmToken", "::", "Identifier", ")", "&&", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ".", "lower", "(", ")", "==", "<STR_LIT>", ".req", "<STR_LIT>", ")", "{", "parseDirectiveReq", "(", "Name", ",", "NameLoc", ")", ";", "return", "true", ";", "}", "size_t", "Start", "=", "<NUM_LIT>", ",", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ")", ";", "StringRef", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "if", "(", "Head", "==", "<STR_LIT>", "ic", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "dc", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "at", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "tlbi", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "cfp", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "dvp", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "cpp", "<STR_LIT>", ")", "return", "parseSysAlias", "(", "Head", ",", "NameLoc", ",", "Operands", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "Head", ",", "NameLoc", ",", "getContext", "(", ")", ")", ")", ";", "Mnemonic", "=", "Head", ";", "if", "(", "(", "Head", "==", "<STR_LIT>", "b", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "bc", "<STR_LIT>", ")", "&&", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ",", "Start", "+", "<NUM_LIT>", ")", ";", "Head", "=", "Name", ".", "slice", "(", "Start", "+", "<NUM_LIT>", ",", "Next", ")", ";", "SMLoc", "SuffixLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "(", "Head", ".", "data", "(", ")", "-", "Name", ".", "data", "(", ")", ")", ")", ";", "std", "::", "string", "Suggestion", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "parseCondCodeString", "(", "Head", ",", "Suggestion", ")", ";", "if", "(", "CC", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "std", "::", "string", "Msg", "=", "<STR_LIT>", "invalid condition code", "<STR_LIT>", ";", "if", "(", "!", "Suggestion", ".", "empty", "(", ")", ")", "Msg", "+=", "<STR_LIT>", ", did you mean ", "<STR_LIT>", "+", "Suggestion", "+", "<STR_LIT>", "?", "<STR_LIT>", ";", "return", "Error", "(", "SuffixLoc", ",", "Msg", ")", ";", "}", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", ".", "<STR_LIT>", ",", "SuffixLoc", ",", "getContext", "(", ")", ",", "true", ")", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateCondCode", "(", "CC", ",", "NameLoc", ",", "NameLoc", ",", "getContext", "(", ")", ")", ")", ";", "}", "while", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'", ".", "'", ",", "Start", "+", "<NUM_LIT>", ")", ";", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "SMLoc", "SuffixLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "(", "Head", ".", "data", "(", ")", "-", "Name", ".", "data", "(", ")", ")", "+", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "Head", ",", "SuffixLoc", ",", "getContext", "(", ")", ",", "true", ")", ")", ";", "}", "bool", "condCodeFourthOperand", "=", "(", "Head", "==", "<STR_LIT>", "ccmp", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "ccmn", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "fccmp", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "fccmpe", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "fcsel", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "csel", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "csinc", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "csinv", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "csneg", "<STR_LIT>", ")", ";", "bool", "condCodeSecondOperand", "=", "(", "Head", "==", "<STR_LIT>", "cset", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "csetm", "<STR_LIT>", ")", ";", "bool", "condCodeThirdOperand", "=", "(", "Head", "==", "<STR_LIT>", "cinc", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "cinv", "<STR_LIT>", "||", "Head", "==", "<STR_LIT>", "cneg", "<STR_LIT>", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "unsigned", "N", "=", "<NUM_LIT>", ";", "do", "{", "if", "(", "parseOperand", "(", "Operands", ",", "(", "N", "==", "<NUM_LIT>", "&&", "condCodeFourthOperand", ")", "||", "(", "N", "==", "<NUM_LIT>", "&&", "condCodeThirdOperand", ")", "||", "(", "N", "==", "<NUM_LIT>", "&&", "condCodeSecondOperand", ")", ",", "condCodeSecondOperand", "||", "condCodeThirdOperand", ")", ")", "{", "return", "true", ";", "}", "if", "(", "parseOptionalToken", "(", "AsmToken", "::", "RBrac", ")", ")", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", "]", "<STR_LIT>", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ")", ")", ";", "if", "(", "parseOptionalToken", "(", "AsmToken", "::", "Exclaim", ")", ")", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", "!", "<STR_LIT>", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ")", ")", ";", "if", "(", "parseOptionalToken", "(", "AsmToken", "::", "RCurly", ")", ")", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateToken", "(", "<STR_LIT>", "}", "<STR_LIT>", ",", "getLoc", "(", ")", ",", "getContext", "(", ")", ")", ")", ";", "++", "N", ";", "}", "while", "(", "parseOptionalToken", "(", "AsmToken", "::", "Comma", ")", ")", ";", "}", "if", "(", "parseToken", "(", "AsmToken", "::", "EndOfStatement", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>", ")", ")", "return", "true", ";", "return", "false", ";", "}" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "<STR_LIT>", ")" ]

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

[ "true", ";" ]

[ "switch", "(", "intrinId", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "tpc_ld_tnsr", ":", "StoreId", "=", "Intrinsic", "::", "tpc_st_tnsr", ";", "break", ";", "}", "if", "(", "LoadId", "==", "Intrinsic", "::", "not", "_", "intrinsic", ")", "LoadId", "=", "intrinId", ";", "else", "return", "LoadId", "==", "intrinId", ";", "return" ]

[ "i", "*", "<NUM_LIT>", "+", "j", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "}", "else", "if", "(", "ShuffleKind", "==", "<NUM_LIT>", ")", "{", "unsigned", "j", "=", "IsLE", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "i", "+=", "<NUM_LIT>", ")", "if", "(", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i", "*", "<NUM_LIT>", "+", "j", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", "," ]

[ "StringRef", "AArch64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "<STR_LIT>", "<STR_LIT>", ";", "case", "VK_LO12", ":", "return", "<STR_LIT>", ":lo12:", "<STR_LIT>", ";", "case", "VK_ABS_G3", ":", "return", "<STR_LIT>", ":abs_g3:", "<STR_LIT>", ";", "case", "VK_ABS_G2", ":", "return", "<STR_LIT>", ":abs_g2:", "<STR_LIT>", ";", "case", "VK_ABS_G2_S", ":", "return", "<STR_LIT>", ":abs_g2_s:", "<STR_LIT>", ";", "case", "VK_ABS_G2_NC", ":", "return", "<STR_LIT>", ":abs_g2_nc:", "<STR_LIT>", ";", "case", "VK_ABS_G1", ":", "return", "<STR_LIT>", ":abs_g1:", "<STR_LIT>", ";", "case", "VK_ABS_G1_S", ":", "return", "<STR_LIT>", ":abs_g1_s:", "<STR_LIT>", ";", "case", "VK_ABS_G1_NC", ":", "return", "<STR_LIT>", ":abs_g1_nc:", "<STR_LIT>", ";", "case", "VK_ABS_G0", ":", "return", "<STR_LIT>", ":abs_g0:", "<STR_LIT>", ";", "case", "VK_ABS_G0_S", ":", "return", "<STR_LIT>", ":abs_g0_s:", "<STR_LIT>", ";", "case", "VK_ABS_G0_NC", ":", "return", "<STR_LIT>", ":abs_g0_nc:", "<STR_LIT>", ";", "case", "VK_DTPREL_G2", ":", "return", "<STR_LIT>", ":dtprel_g2:", "<STR_LIT>", ";", "case", "VK_DTPREL_G1", ":", "return", "<STR_LIT>", ":dtprel_g1:", "<STR_LIT>", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "<STR_LIT>", ":dtprel_g1_nc:", "<STR_LIT>", ";", "case", "VK_DTPREL_G0", ":", "return", "<STR_LIT>", ":dtprel_g0:", "<STR_LIT>", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "<STR_LIT>", ":dtprel_g0_nc:", "<STR_LIT>", ";", "case", "VK_DTPREL_HI12", ":", "return", "<STR_LIT>", ":dtprel_hi12:", "<STR_LIT>", ";", "case", "VK_DTPREL_LO12", ":", "return", "<STR_LIT>", ":dtprel_lo12:", "<STR_LIT>", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "<STR_LIT>", ":dtprel_lo12_nc:", "<STR_LIT>", ";", "case", "VK_TPREL_G2", ":", "return", "<STR_LIT>", ":tprel_g2:", "<STR_LIT>", ";", "case", "VK_TPREL_G1", ":", "return", "<STR_LIT>", ":tprel_g1:", "<STR_LIT>", ";", "case", "VK_TPREL_G1_NC", ":", "return", "<STR_LIT>", ":tprel_g1_nc:", "<STR_LIT>", ";", "case", "VK_TPREL_G0", ":", "return", "<STR_LIT>", ":tprel_g0:", "<STR_LIT>", ";", "case", "VK_TPREL_G0_NC", ":", "return", "<STR_LIT>", ":tprel_g0_nc:", "<STR_LIT>", ";", "case", "VK_TPREL_HI12", ":", "return", "<STR_LIT>", ":tprel_hi12:", "<STR_LIT>", ";", "case", "VK_TPREL_LO12", ":", "return", "<STR_LIT>", ":tprel_lo12:", "<STR_LIT>", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "<STR_LIT>", ":tprel_lo12_nc:", "<STR_LIT>", ";", "case", "VK_TLSDESC_LO12", ":", "return", "<STR_LIT>", ":tlsdesc_lo12:", "<STR_LIT>", ";", "case", "VK_ABS_PAGE", ":", "return", "<STR_LIT>", "<STR_LIT>", ";", "case", "VK_ABS_PAGE_NC", ":", "return", "<STR_LIT>", ":pg_hi21_nc:", "<STR_LIT>", ";", "case", "VK_GOT_PAGE", ":", "return", "<STR_LIT>", ":got:", "<STR_LIT>", ";", "case", "VK_GOT_LO12", ":", "return", "<STR_LIT>", ":got_lo12:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "<STR_LIT>", ":gottprel:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "<STR_LIT>", ":gottprel_lo12:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_G1", ":", "return", "<STR_LIT>", ":gottprel_g1:", "<STR_LIT>", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "<STR_LIT>", ":gottprel_g0_nc:", "<STR_LIT>", ";", "case", "VK_TLSDESC", ":", "return", "<STR_LIT>", "<STR_LIT>", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "<STR_LIT>", ":tlsdesc:", "<STR_LIT>", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid ELF symbol kind", "<STR_LIT>", ")", ";", "}", "}" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "<FIXS>", "VEX", ",", "Sched", "[", "WriteCvtPD2PS", ".", "Folded", "]", ">", ",", "VEX_WIG", ";", "<FIXE>" ]

[ "def", "VCVTPD2PSrm", ":", "VPDI", "<NUM_LIT>", ",", "MRMSrcMem", ",", "(", "outs", "VR128", ":", "$", "dst", ")", ",", "(", "ins", "f128mem", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "VR128", ":", "$", "dst", ",", "(", "X86vfpround", "(", "loadv2f64", "addr", ":", "$", "src", ")", ")", ")", "]", ">", ",", "<BUGS>", "VEX", ",", "Sched", "[", "WriteCvtF2FLd", "]", ">", ",", "VEX_WIG", ";", "<BUGE>", "def", ":", "InstAlias", "<STR_LIT>", ",", "(", "VCVTPD2PSrm", "VR128", ":", "$", "dst", ",", "f128mem", ":", "$", "src", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", ">", ";" ]

[ "static", "rtx", "s390_execute_target", "(", "rtx", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "s390_execute_label", "(", "insn", ")", ")", ";", "if", "(", "XVECLEN", "(", "pattern", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "pattern", "=", "copy_rtx", "(", "XVECEXP", "(", "pattern", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "rtvec", "vec", "=", "rtvec_alloc", "(", "XVECLEN", "(", "pattern", ",", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ";", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "pattern", ",", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "i", "++", ")", "RTVEC_ELT", "(", "vec", ",", "i", ")", "=", "copy_rtx", "(", "XVECEXP", "(", "pattern", ",", "<NUM_LIT>", ",", "i", "+", "<NUM_LIT>", ")", ")", ";", "pattern", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "}", "return", "pattern", ";", "}" ]

[ "For", "an", "execute", "INSN", ",", "extract", "the", "execute", "target", "template", "." ]

[ "InPhysReg", ")", ";" ]

[ "Type", "*", "ATy", "=", "Arg", ".", "getType", "(", ")", ";", "unsigned", "Width", "=", "<NUM_LIT>", ";", "if", "(", "ATy", "->", "isIntegerTy", "(", ")", ")", "Width", "=", "ATy", "->", "getIntegerBitWidth", "(", ")", ";", "else", "if", "(", "ATy", "->", "isPointerTy", "(", ")", ")", "Width", "=", "<NUM_LIT>", ";", "if", "(", "Width", "==", "<NUM_LIT>", "||", "Width", ">", "<NUM_LIT>", ")", "break", ";", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", ")", "continue", ";", "InPhysReg", "=", "getNextPhysReg", "(", "InPhysReg", ",", "Width", ")", ";", "if", "(", "!", "InPhysReg", ")", "break", ";", "InVirtReg", "=", "getVirtRegFor", "(" ]

[ "<FIXS>", "sorry", "(", "<STR_LIT>", "code model %qs with %<-f%s%>", "<STR_LIT>", ",", "<STR_LIT>", "large", "<STR_LIT>", ",", "<FIXE>" ]

[ "#", "endifbreak", ";", "case", "AARCH64_CMODEL_LARGE", ":", "<BUGS>", "sorry", "(", "<STR_LIT>", "code model %qs with -f%s", "<STR_LIT>", ",", "<STR_LIT>", "large", "<STR_LIT>", ",", "<BUGE>", "opts", "->", "x_flag_pic", ">", "<NUM_LIT>", "?", "<STR_LIT>", "PIC", "<STR_LIT>", ":", "<STR_LIT>", "pic", "<STR_LIT>", ")", ";", "break", ";", "default", ":" ]

[ "}" ]

[ "Op", "->", "RegIdx", ".", "Kind", "=", "RegKind", ";", "Op", "->", "RegIdx", ".", "Tok", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Op", "->", "RegIdx", ".", "Tok", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";" ]

[ "false", ";" ]

[ "if", "(", "GV", ".", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "const", "User", "*", "U", ":", "GV", ".", "users", "(", ")", ")", "{", "const", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "{", "Align", "Alignment", "=", "DL", ".", "getValueOrABITypeAlignment", "(", "GV", ".", "getAlign", "(", ")", ",", "GV", ".", "getValueType", "(", ")", ")", ";", "uint64_t", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "CurrentLocalMemUsage", "=", "alignTo", "(", "CurrentLocalMemUsage", ",", "Alignment", ")", ";", "CurrentLocalMemUsage", "+=", "AllocSize", ";", "break", ";", "}", "}", "}", "unsigned", "MaxOccupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "CurrentLocalMemUsage", ",", "F", ")", ";", "unsigned", "OccupancyHint", "=", "ST", ".", "getWavesPerEU", "(", "F", ")", ".", "second", ";", "if", "(", "OccupancyHint", "==", "<NUM_LIT>", ")", "OccupancyHint", "=", "<NUM_LIT>", ";", "OccupancyHint", "=", "std", "::", "min", "(", "OccupancyHint", ",", "ST", ".", "getMaxWavesPerEU", "(", ")", ")", ";", "MaxOccupancy", "=", "std", "::", "min", "(", "OccupancyHint", ",", "MaxOccupancy", ")", ";", "unsigned", "MaxSizeWithWaveCount", "=", "ST", ".", "getMaxLocalMemSizeWithWaveCount", "(", "MaxOccupancy", ",", "F", ")", ";", "if", "(", "CurrentLocalMemUsage", ">", "MaxSizeWithWaveCount", ")", "return" ]

[ "(", "one_var", "==", "<NUM_LIT>", "?", "<NUM_LIT>", "+", "<NUM_LIT>", ":", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ")", ")", ";" ]

[ "case", "E_V2DImode", ":", "if", "(", "one_var", "!=", "<NUM_LIT>", ")", "return", "false", ";", "var", "=", "force_reg", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "var", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "mode", ",", "var", ",", "CONST0_RTX", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "x", ")", ")", ";", "return", "true", ";", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "if", "(", "!", "REG_P", "(", "target", ")", "||", "REGNO", "(", "target", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "new", "_", "target", "=", "gen_reg_rtx", "(", "mode", ")", ";", "else", "new", "_", "target", "=", "target", ";", "var", "=", "force_reg", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "var", ")", ";", "x", "=", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "var", ")", ";", "x", "=", "gen_rtx_VEC_MERGE", "(", "mode", ",", "x", ",", "CONST0_RTX", "(", "mode", ")", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "new", "_", "target", ",", "x", ")", ")", ";", "if", "(", "one_var", "!=", "<NUM_LIT>", ")", "{", "if", "(", "mode", "!=", "V4SFmode", "&&", "TARGET_SSE2", ")", "{", "emit_insn", "(", "gen_sse2_pshufd_1", "(", "new", "_", "target", ",", "new", "_", "target", ",", "const1_rtx", ",", "GEN_INT", "(", "one_var", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "one_var", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "one_var", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "target", "!=", "new", "_", "target", ")", "emit_move_insn", "(", "target", ",", "new", "_", "target", ")", ";", "return", "true", ";", "}", "if", "(", "mode", "!=", "V4SFmode", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "V4SFmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_lowpart", "(", "V4SFmode", ",", "new", "_", "target", ")", ")", ";", "}", "else", "tmp", "=", "new", "_", "target", ";", "emit_insn", "(", "gen_sse_shufps_v4sf", "(", "tmp", ",", "tmp", ",", "tmp", ",", "const1_rtx", ",", "GEN_INT", "(", "one_var", "==", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "one_var", "==", "<NUM_LIT>", "?", "<NUM_LIT>", "+", "<NUM_LIT>", ":", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ",", "GEN_INT" ]

[ ")", ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const", "(", "symbol_ref", "<STR_LIT>", ")" ]

[ "logical_imm32", ":", "$", "imm", ")", ")", "]", ">", "{" ]

[ "def", "Wri", ":", "BaseLogicalImm", "<", "opc", ",", "GPR32sp", ",", "GPR32", ",", "logical_imm32", ",", "mnemonic", ",", "[", "(", "set", "GPR32sp", ":", "$", "Rd", ",", "(", "OpNode", "GPR32", ":", "$", "Rn", "," ]

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

[ "(", "vec_merge", ":", "SUBST_V", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "SUBST_V", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ ")" ]

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

[ "SDValue", "SystemZTargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported calling convention", "<STR_LIT>", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "v", ")", ")", ")", ",", "(", "VTI", ".", "Vec", "(", "Inst", "$", "v", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "VTI", ".", "Vec", "(", "unpred_op", "(", "VTI", ".", "Vec", "MQPR", ":", "$" ]

[ "let", "opNewValue", "=", "<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", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "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>", ";" ]

[ "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "return", "new", "AArch64TargetWinCOFFStreamer", "(", "S", ")", ";" ]

[ "MCTargetStreamer", "*", "llvm", "::", "createAArch64ObjectTargetStreamer", "(", "MCStreamer", "&", "S", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "Triple", "&", "TT", "=", "STI", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "return", "new", "AArch64TargetELFStreamer", "(", "S", ")", ";" ]

[ "let", "cofRelax2", "=", "<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>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_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" ]

[ "let", "isExtentSigned", "=", "<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", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ ">=", "<NUM_LIT>", ")", "return", "true", ";" ]

[ "if", "(", "lra_in_progress", "&&", "(", "class1", "==", "NO_REGS", "||", "class2", "==", "NO_REGS", ")", ")", "return", "false", ";", "if", "(", "(", "(", "class1", "==", "FP_REGS", ")", "!=", "(", "class2", "==", "FP_REGS", ")", ")", "&&", "(", "(", "TARGET_FLOATXX", "&&", "!", "ISA_HAS_MXHC1", ")", "||", "TARGET_O32_FP64A_ABI", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")" ]

[ "return", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ";" ]

[ "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetConstantPool", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetJumpTable", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetGlobalAddress", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetExternalSymbol", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "MCSymbol", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetBlockAddress", ")", "return", "false", ";", "Imm", "=", "N", ";" ]

[ "<FIXS>", "AVX512AIi8Base", ",", "EVEX", ",", "VVVV", ";", "<FIXE>" ]

[ "defm", "NAME", ":", "avx512_common_3Op_imm8", "OpcodeStr", ",", "VTInfo_FP", ",", "<NUM_LIT>", ",", "X86Shufp", ",", "SchedWriteFShuffle", ">", ",", "EVEX_CD8", "VTInfo_FP", ".", "info512", ".", "EltSize", ",", "CD8VF", ">", ",", "<BUGS>", "AVX512AIi8Base", ",", "EVEX_4V", ";", "<BUGE>", "}", "defm", "VSHUFPS", ":", "avx512_shufp", "<STR_LIT>", ",", "avx512vl_f32_info", ">", ",", "PS", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_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>", ">", "Pv4", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "nregs", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm4", ";" ]

[ "createReplacer", "(", "X86", "::", "MOV8mr", ",", "X86", "::", "KMOVBmk", ")", ";" ]

[ "createReplacer", "(", "X86", "::", "MOV64rr", ",", "X86", "::", "KMOVQkk", ")", ";", "createReplacer", "(", "X86", "::", "SHR32ri", ",", "X86", "::", "KSHIFTRDri", ")", ";", "createReplacer", "(", "X86", "::", "SHR64ri", ",", "X86", "::", "KSHIFTRQri", ")", ";", "createReplacer", "(", "X86", "::", "SHL32ri", ",", "X86", "::", "KSHIFTLDri", ")", ";", "createReplacer", "(", "X86", "::", "SHL64ri", ",", "X86", "::", "KSHIFTLQri", ")", ";", "createReplacer", "(", "X86", "::", "ADD32rr", ",", "X86", "::", "KADDDrr", ")", ";", "createReplacer", "(", "X86", "::", "ADD64rr", ",", "X86", "::", "KADDQrr", ")", ";", "createReplacer", "(", "X86", "::", "NOT32r", ",", "X86", "::", "KNOTDrr", ")", ";", "createReplacer", "(", "X86", "::", "NOT64r", ",", "X86", "::", "KNOTQrr", ")", ";", "createReplacer", "(", "X86", "::", "OR32rr", ",", "X86", "::", "KORDrr", ")", ";", "createReplacer", "(", "X86", "::", "OR64rr", ",", "X86", "::", "KORQrr", ")", ";", "createReplacer", "(", "X86", "::", "AND32rr", ",", "X86", "::", "KANDDrr", ")", ";", "createReplacer", "(", "X86", "::", "AND64rr", ",", "X86", "::", "KANDQrr", ")", ";", "createReplacer", "(", "X86", "::", "ANDN32rr", ",", "X86", "::", "KANDNDrr", ")", ";", "createReplacer", "(", "X86", "::", "ANDN64rr", ",", "X86", "::", "KANDNQrr", ")", ";", "createReplacer", "(", "X86", "::", "XOR32rr", ",", "X86", "::", "KXORDrr", ")", ";", "createReplacer", "(", "X86", "::", "XOR64rr", ",", "X86", "::", "KXORQrr", ")", ";", "}", "if", "(", "STI", "->", "hasDQI", "(", ")", ")", "{", "createReplacer", "(", "X86", "::", "ADD8rr", ",", "X86", "::", "KADDBrr", ")", ";", "createReplacer", "(", "X86", "::", "ADD16rr", ",", "X86", "::", "KADDWrr", ")", ";", "createReplacer", "(", "X86", "::", "AND8rr", ",", "X86", "::", "KANDBrr", ")", ";", "createReplacer", "(", "X86", "::", "MOV8rm", ",", "X86", "::", "KMOVBkm", ")", ";" ]

[ "static", "void", "sh_print_operand_address", "(", "FILE", "*", "stream", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@%s", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "index", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@(%d,%s)", "<STR_LIT>", ",", "(", "int", ")", "INTVAL", "(", "index", ")", ",", "reg_names", "[", "true_regnum", "(", "base", ")", "]", ")", ";", "break", ";", "case", "REG", ":", "case", "SUBREG", ":", "{", "int", "base_num", "=", "true_regnum", "(", "base", ")", ";", "int", "index_num", "=", "true_regnum", "(", "index", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "@(r0,%s)", "<STR_LIT>", ",", "reg_names", "[", "MAX", "(", "base_num", ",", "index_num", ")", "]", ")", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@-%s", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@%s+", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "default", ":", "x", "=", "mark_constant_pool_use", "(", "x", ")", ";", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "}" ]

[ "Print", "the", "operand", "address", "in", "x", "to", "the", "stream", "." ]

[ "return", "MatchingElements", ";" ]

[ "T", "Parts", "[", "sizeof", "(", "int64_t", ")", "/", "sizeof", "(", "T", ")", "]", ";", "}", "Vec", "{", "Imm", "}", ";", "bool", "MatchingElements", "=", "true", ";", "for", "(", "auto", "&", "Elem", ":", "Vec", ".", "Parts", ")", "MatchingElements", "&=", "(", "Elem", "==", "Vec", ".", "Parts", "[", "<NUM_LIT>", "]", ")", ";" ]

[ "unsigned", "DCPU16InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "LLVMContext", "&", "Ctx", "=", "F", ".", "getContext", "(", ")", ";" ]

[ "if", "(", "A", ".", "isStringAttribute", "(", ")", ")", "{", "StringRef", "Str", "=", "A", ".", "getValueAsString", "(", ")", ";", "if", "(", "Str", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "Result", ")", ")", "{" ]

[ ",", "_", "_", "M", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_min_epi64", "(", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m512i", "_", "_", "A", ",", "_", "_", "m512i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pminsq512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")", "_", "_", "B", ",", "(", "_", "_", "v8di", ")", "_", "mm512_setzero_si512", "(", ")" ]

[ "sign_extract", "zero_extract", "]", ")" ]

[ "(", "define_code_iterator", "any_extract", "[" ]

[ "*", "_", "_", "a", "-=", "_", "_", "imm", "*", "<NUM_LIT>", "u", ";" ]

[ "_", "_", "arm_vddupq_m_wb_u16", "(", "uint16x8_t", "_", "_", "inactive", ",", "uint32_t", "*", "_", "_", "a", ",", "const", "int", "_", "_", "imm", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "uint16x8_t", "_", "_", "res", "=", "_", "_", "builtin_mve_vddupq_m_n_uv8hi", "(", "_", "_", "inactive", ",", "*", "_", "_", "a", ",", "_", "_", "imm", ",", "_", "_", "p", ")", ";" ]

[ "_", "m", ",", "_", "_", "m64", "_", "_", "count", ")", "{" ]

[ "static", "_", "_", "inline", "_", "_", "m64", "_", "mm_sra_si64", "(", "_", "_", "m64", "_" ]

[ "}", ")" ]

[ "rtx", "mem", "=", "gen_rtx_MEM", "(", "CImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "emit_insn", "(", "gen_aarch64_st1_x3_", "<", "VALLDIF", ":", "mode", ">", "(", "mem", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE" ]

[ "if", "(", "getSVEStackSize", "(", "MF", ")", ")", "return", "false", ";" ]

[ "if", "(", "needsWinCFI", "(", "MF", ")", "&&", "AFI", "->", "getCalleeSavedStackSize", "(", ")", ">", "<NUM_LIT>", "&&", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", "return", "false", ";", "if", "(", "StackBumpBytes", ">=", "<NUM_LIT>", "||", "windowsRequiresStackProbe", "(", "MF", ",", "StackBumpBytes", ")", ")", "return", "false", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "return", "false", ";", "if", "(", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", ")", "return", "false", ";", "if", "(", "canUseRedZone", "(", "MF", ")", ")", "return", "false", ";" ]

[ "int", "main", "(", "int", "argc", ",", "char", "*", "*", "argv", ")", "{", "int", "i", ";", "char", "cwdev", "[", "<NUM_LIT>", "]", ",", "*", "devptr", ";", "int", "devlen", ";", "char", "*", "cwd", "=", "getcwd", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "devptr", "=", "strchr", "(", "cwd", ",", "'", ":", "'", ")", ";", "devlen", "=", "(", "devptr", "-", "cwd", ")", "+", "<NUM_LIT>", ";", "strncpy", "(", "cwdev", ",", "cwd", ",", "devlen", ")", ";", "cwdev", "[", "devlen", "]", "=", "'", "\\0", "'", ";", "search_dirs", "=", "xstrdup", "(", "system_search_dirs", ")", ";", "defines", "=", "xstrdup", "(", "default_defines", ")", ";", "addarg", "(", "<STR_LIT>", "cc", "<STR_LIT>", ")", ";", "preprocess_args", "(", "&", "argc", ",", "argv", ")", ";", "process_args", "(", "&", "argc", ",", "argv", ")", ";", "if", "(", "strlen", "(", "search_dirs", ")", ">", "<NUM_LIT>", ")", "{", "addarg", "(", "<STR_LIT>", "/include=(", "<STR_LIT>", ")", ";", "addarg", "(", "search_dirs", ")", ";", "addarg", "(", "<STR_LIT>", ")", "<STR_LIT>", ")", ";", "}", "if", "(", "strlen", "(", "defines", ")", ">", "<NUM_LIT>", ")", "{", "addarg", "(", "<STR_LIT>", "/define=(", "<STR_LIT>", ")", ";", "addarg", "(", "defines", ")", ";", "addarg", "(", "<STR_LIT>", ")", "<STR_LIT>", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "argc", ";", "i", "++", ")", "{", "int", "arg_len", "=", "strlen", "(", "argv", "[", "i", "]", ")", ";", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-o", "<STR_LIT>", ")", "==", "<NUM_LIT>", ")", "i", "++", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-v", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "strcmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-E", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "strcmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-c", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "strncmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-g", "<STR_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "||", "strncmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-O", "<STR_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "||", "strcmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-save-temps", "<STR_LIT>", ")", "==", "<NUM_LIT>", "||", "(", "arg_len", ">", "<NUM_LIT>", "&&", "strncmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-I", "<STR_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "||", "(", "arg_len", ">", "<NUM_LIT>", "&&", "strncmp", "(", "argv", "[", "i", "]", ",", "<STR_LIT>", "-D", "<STR_LIT>", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "(", "argv", "[", "i", "]", "[", "<NUM_LIT>", "]", "==", "'", "/", "'", ")", "&&", "(", "strchr", "(", "&", "argv", "[", "i", "]", "[", "<NUM_LIT>", "]", ",", "'", "/", "'", ")", "==", "<NUM_LIT>", ")", ")", "addarg", "(", "argv", "[", "i", "]", ")", ";", "else", "{", "char", "buff", "[", "<NUM_LIT>", "]", ",", "*", "ptr", ";", "ptr", "=", "to_host_file_spec", "(", "argv", "[", "i", "]", ")", ";", "arg_len", "=", "strlen", "(", "ptr", ")", ";", "if", "(", "ptr", "[", "<NUM_LIT>", "]", "==", "'", "[", "'", ")", "sprintf", "(", "buff", ",", "<STR_LIT>", "%s%s", "<STR_LIT>", ",", "cwdev", ",", "ptr", ")", ";", "else", "if", "(", "strchr", "(", "ptr", ",", "'", ":", "'", ")", ")", "sprintf", "(", "buff", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "ptr", ")", ";", "else", "sprintf", "(", "buff", ",", "<STR_LIT>", "%s%s", "<STR_LIT>", ",", "cwd", ",", "ptr", ")", ";", "ptr", "=", "xstrdup", "(", "buff", ")", ";", "addarg", "(", "ptr", ")", ";", "}", "}", "addarg", "(", "NULL", ")", ";", "if", "(", "verbose", ")", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "comp_arg_index", ";", "i", "++", ")", "printf", "(", "<STR_LIT>", "%s ", "<STR_LIT>", ",", "comp_args", "[", "i", "]", ")", ";", "putchar", "(", "'", "\\n", "'", ")", ";", "}", "{", "int", "i", ";", "int", "len", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "comp_args", "[", "i", "]", ";", "i", "++", ")", "len", "=", "len", "+", "strlen", "(", "comp_args", "[", "i", "]", ")", "+", "<NUM_LIT>", ";", "{", "char", "*", "allargs", "=", "(", "char", "*", ")", "alloca", "(", "len", "+", "<NUM_LIT>", ")", ";", "Descr", "cmd", ";", "int", "status", ";", "int", "status1", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "len", "+", "<NUM_LIT>", ";", "i", "++", ")", "allargs", "[", "i", "]", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "comp_args", "[", "i", "]", ";", "i", "++", ")", "{", "strcat", "(", "allargs", ",", "comp_args", "[", "i", "]", ")", ";", "strcat", "(", "allargs", ",", "<STR_LIT>", "<STR_LIT>", ")", ";", "}", "cmd", ".", "adr", "=", "allargs", ";", "cmd", ".", "len", "=", "len", ";", "cmd", ".", "mbz", "=", "<NUM_LIT>", ";", "i", "=", "LIB", "$", "SPAWN", "(", "&", "cmd", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "&", "status", ")", ";", "if", "(", "(", "i", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "{", "LIB", "$", "SIGNAL", "(", "i", ")", ";", "exit", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "(", "status", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "status1", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "exit", "(", "<NUM_LIT>", ")", ";", "exit", "(", "<NUM_LIT>", ")", ";", "}", "}", "}" ]

[ "Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "." ]

[ "OutStreamer", "->", "EmitIntValue", "(", "RsrcReg", ",", "<NUM_LIT>", ")", ";" ]

[ "void", "AMDGPUAsmPrinter", "::", "EmitProgramInfoSI", "(", "const", "MachineFunction", "&", "MF", ",", "const", "SIProgramInfo", "&", "KernelInfo", ")", "{", "const", "AMDGPUSubtarget", "&", "STM", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RsrcReg", "=", "getRsrcReg", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", ";", "if", "(", "AMDGPU", "::", "isCompute", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", ")", "{", "OutStreamer", "->", "EmitIntValue", "(", "R_00B848_COMPUTE_PGM_RSRC1", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "EmitIntValue", "(", "KernelInfo", ".", "ComputePGMRSrc1", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "EmitIntValue", "(", "R_00B84C_COMPUTE_PGM_RSRC2", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "EmitIntValue", "(", "KernelInfo", ".", "ComputePGMRSrc2", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "EmitIntValue", "(", "R_00B860_COMPUTE_TMPRING_SIZE", ",", "<NUM_LIT>", ")", ";", "OutStreamer", "->", "EmitIntValue", "(", "S_00B860_WAVESIZE", "(", "KernelInfo", ".", "ScratchBlocks", ")", ",", "<NUM_LIT>", ")", ";", "}", "else", "{" ]

[ "<FIXS>", "if", "(", "!", "sel_sched_p", "(", ")", "&&", "INSN_PRIORITY_KNOWN", "(", "tmp", ")", ")", "<FIXE>" ]

[ "for", "(", "i", "=", "pos", ";", "i", "*", "pn_ready", "-", "<NUM_LIT>", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "<NUM_LIT>", "]", ";", "ready", "[", "*", "pn_ready", "-", "<NUM_LIT>", "]", "=", "tmp", ";", "<BUGS>", "if", "INSN_PRIORITY_KNOWN", "(", "tmp", ")", "<BUGE>", "INSN_PRIORITY", "(", "tmp", ")", "++", ";", "first_store_pos", "=", "-", "<NUM_LIT>", ";", "break", ";" ]

[ ")", ";" ]

[ "unsigned", "addTF", "=", "(", "(", "model", "==", "TLSModel", "::", "GeneralDynamic", ")", "?", "SparcMCExpr", "::", "VK_Sparc_TLS_GD_ADD", ":", "SparcMCExpr", "::", "VK_Sparc_TLS_LDM_ADD", ")", ";", "unsigned", "callTF", "=", "(", "(", "model", "==", "TLSModel", "::", "GeneralDynamic", ")", "?", "SparcMCExpr", "::", "VK_Sparc_TLS_GD_CALL", ":", "SparcMCExpr", "::", "VK_Sparc_TLS_LDM_CALL", ")", ";", "SDValue", "HiLo", "=", "makeHiLoPair", "(", "Op", ",", "HiTF", ",", "LoTF", ",", "DAG", ")", ";", "SDValue", "Base", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ")", ";", "SDValue", "Argument", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "Base", ",", "HiLo", ",", "withTargetFlags", "(", "Op", ",", "addTF", ",", "DAG", ")", ")", ";", "SDValue", "Chain", "=", "DAG", ".", "getEntryNode", "(", ")", ";", "SDValue", "InFlag", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_START", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "true", ")", ",", "DL", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "Argument", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "<STR_LIT>", "__tls_get_addr", "<STR_LIT>", ",", "PtrVT", ")", ";", "SDValue", "Symbol", "=", "withTargetFlags", "(", "Op", ",", "callTF", ",", "DAG", ")", ";", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "Ops", ".", "push_back", "(", "Symbol", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "PtrVT", ")", ")", ";", "const", "uint32_t", "*", "Mask", "=", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", "->", "getCallPreservedMask", "(", "CallingConv", "::", "C", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "NodeTys", ",", "Ops", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "true", ")", ",", "InFlag", ",", "DL", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "Ret", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "PtrVT", ",", "InFlag", ")", ";", "if", "(", "model", "!=", "TLSModel", "::", "LocalDynamic", ")", "return", "Ret", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "withTargetFlags", "(", "Op", ",", "SparcMCExpr", "::", "VK_Sparc_TLS_LDO_HIX22", ",", "DAG", ")", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "PtrVT", ",", "withTargetFlags", "(", "Op", ",", "SparcMCExpr", "::", "VK_Sparc_TLS_LDO_LOX10", ",", "DAG", ")", ")", ";", "HiLo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "DL", ",", "PtrVT", ",", "Hi", ",", "Lo" ]

[ "}" ]

[ "def", "Wri", ":", "BaseBitfieldImmWith2RegArgs", "<", "opc", ",", "GPR32", ",", "imm0_31", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ">", ";" ]

[ "def", "AArch64cbnz", ":", "SDNode", "<", "<STR_LIT>", ",", "SDT_AArch64cbz", ",", "[", "SDNPHasChain", "]" ]

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

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

[ ")", "_", "mm512_setzero_si512", "(", ")", ",", "(", "_", "_", "mmask32", ")", "_", "_", "M", ")", ";" ]

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

[ "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "Subtarget", ")", ")", ")", ",", "DataLayout", "(", "Subtarget", ".", "isAPCS_ABI", "(", ")", "?", "std", "::", "string", "(", "<STR_LIT>", "e-p:32:32-f64:32:32-i64:32:32-", "<STR_LIT>", "<STR_LIT>", "i16:16:32-i8:8:32-i1:8:32-", "<STR_LIT>", "<STR_LIT>", "v128:32:128-v64:32:64-a:0:32-n32", "<STR_LIT>", ")", ":" ]

[ "ThumbTargetMachine", "::", "ThumbTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "ARMBaseTargetMachine", "(", "T", ",", "TT", ",", "FS", ",", "true", ")", ",", "InstrInfo", "(", "Subtarget", ".", "hasThumb2", "(", ")", "?", "(", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "Subtarget", ")", ")", ":", "(" ]

[ ",", "this", ",", "STI", ")", ";" ]

[ "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumbSBit16", ",", "MI", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", ")", "{", "Size", "=", "<NUM_LIT>", ";", "bool", "InITBlock", "=", "ITBlock", ".", "instrInITBlock", "(", ")", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "AddThumb1SBit", "(", "MI", ",", "InITBlock", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumb216", ",", "MI", ",", "insn16", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", "&&", "ITBlock", ".", "instrInITBlock", "(", ")", ")", "result", "=", "MCDisassembler", "::", "SoftFail", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Firstcond", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "Mask", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "ITBlock", ".", "setITState", "(", "Firstcond", ",", "Mask", ")", ";", "}", "return", "result", ";", "}", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "<NUM_LIT>", ",", "bytes", ")", "==", "-", "<NUM_LIT>", ")", "{", "Size", "=", "<NUM_LIT>", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "insn32", "=", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", "|", "(", "bytes", "[", "<NUM_LIT>", "]", "<<", "<NUM_LIT>", ")", ";", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumb32", ",", "MI", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "bool", "InITBlock", "=", "ITBlock", ".", "instrInITBlock", "(", ")", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "AddThumb1SBit", "(", "MI", ",", "InITBlock", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableThumb232", ",", "MI", ",", "insn32", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "<NUM_LIT>", ";", "Check", "(", "result", ",", "AddThumbPredicate", "(", "MI", ")", ")", ";", "return", "result", ";", "}", "MI", ".", "clear", "(", ")", ";", "result", "=", "decodeInstruction", "(", "DecoderTableVFP32", ",", "MI", ",", "insn32", ",", "Address" ]

[ "return", "I", ";" ]

[ "MachineBasicBlock", "::", "iterator", "skipToUncondBrOrEnd", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "assert", "(", "I", "->", "isTerminator", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "End", "&&", "!", "I", "->", "isUnconditionalBranch", "(", ")", ")", "++", "I", ";" ]

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

[ "(", "V2DI", "<STR_LIT>", ")", "(", "VNx2DI", "<STR_LIT>", ")", "(", "VNx2BI", "<STR_LIT>", ")", "(", "V4HF", "<STR_LIT>", ")", "(", "V8HF", "<STR_LIT>", ")", "(", "VNx8HF", "<STR_LIT>", ")", "(", "V2SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "(", "VNx4SF", "<STR_LIT>", ")", "(", "V2DF", "<STR_LIT>", ")", "(", "VNx2DF", "<STR_LIT>", ")", "(", "HF", "<STR_LIT>", ")", "(", "SF", "<STR_LIT>", ")", "(" ]

[ ",", "INDIRECT_BRANCH_THUNK_REGNUM", ",", "regno", ")", ";" ]

[ "if", "(", "return_addr_regno", "!=", "INVALID_REGNUM", ")", "{", "gcc_assert", "(", "comparison_operator", "==", "NULL_RTX", ")", ";", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", " \\tbrasl\\t%%r%d,", "<STR_LIT>", ",", "return_addr_regno", ")", ";", "}", "else", "{", "fputs", "(", "<STR_LIT>", " \\tjg", "<STR_LIT>", ",", "asm_out_file", ")", ";", "if", "(", "comparison_operator", "!=", "NULL_RTX", ")", "print_operand", "(", "asm_out_file", ",", "comparison_operator", ",", "'", "C", "'", ")", ";", "fputs", "(", "<STR_LIT>", "\\t", "<STR_LIT>", ",", "asm_out_file", ")", ";", "}", "if", "(", "TARGET_CPU_Z10", ")", "fprintf", "(", "asm_out_file", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EXRL", "<STR_LIT>", "\\n", "<STR_LIT>", ",", "regno", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EX", "<STR_LIT>", "\\n", "<STR_LIT>" ]

[ "MachineInstr", "*", "Copy", "=", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "Next", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "TLSBaseAddrReg", ")", ".", "addReg", "(", "is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ";" ]

[ "MachineInstr", "*", "SetRegister", "(", "MachineInstr", "&", "I", ",", "unsigned", "*", "TLSBaseAddrReg", ")", "{", "MachineFunction", "*", "MF", "=", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "bool", "is64Bit", "=", "STI", ".", "is64Bit", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "*", "TLSBaseAddrReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "is64Bit", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ")", ";", "MachineInstr", "*", "Next", "=", "I", ".", "getNextNode", "(", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rdd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rdd32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rx32", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2Mods", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "omod", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0Mods", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1Mods", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2Mods", ",", "src2_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0", ",", "src0", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1", ",", "src1", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc2", ",", "src2", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasOMod", ",", "omod", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc0Mods", ",", "src0_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "P", ".", "HasSrc1Mods", ",", "src1_modifiers", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ";" ]

[ ")", ".", "getMBB", "(", ")", "==", "MBB", ")", "return", "Phi", ".", "getOperand", "(", "Idx", ")", ".", "getReg", "(", ")", ";" ]

[ "assert", "(", "Phi", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ",", "End", "=", "Phi", ".", "getNumOperands", "(", ")", ";", "Idx", "!=", "End", ";", "Idx", "+=", "<NUM_LIT>", ")", "if", "(", "Phi", ".", "getOperand", "(", "Idx", "+", "<NUM_LIT>" ]

[ "const", "char", "*", "output_move_double", "(", "rtx", "operands", "[", "]", ",", "rtx", "insn", ")", "{", "rtx", "dest", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "src", "=", "operands", "[", "<NUM_LIT>", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", "{", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "if", "(", "GPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "dest_regno", "-", "GPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "(", "src_regno", "-", "FPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "movfgd %1, %0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "dbl_memory_one_insn_operand", "(", "src", ",", "mode", ")", ")", "return", "<STR_LIT>", "ldd%I1%U1 %M1, %0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "else", "if", "(", "FPR_P", "(", "dest_regno", ")", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "dest_regno", "-", "FPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "(", "src_regno", "-", "GPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "movgfd %1, %0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "else", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "TARGET_DOUBLE", "&&", "(", "(", "dest_regno", "-", "FPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "(", "(", "src_regno", "-", "FPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "<STR_LIT>", "fmovd %1, %0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "if", "(", "dbl_memory_one_insn_operand", "(", "src", ",", "mode", ")", ")", "return", "<STR_LIT>", "lddf%I1%U1 %M1, %0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "int", "src_regno", "=", "REGNO", "(", "src", ")", ";", "if", "(", "GPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "src_regno", "-", "GPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "dbl_memory_one_insn_operand", "(", "dest", ",", "mode", ")", ")", "return", "<STR_LIT>", "std%I0%U0 %1, %M0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "if", "(", "FPR_P", "(", "src_regno", ")", ")", "{", "if", "(", "(", "(", "src_regno", "-", "FPR_FIRST", ")", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "dbl_memory_one_insn_operand", "(", "dest", ",", "mode", ")", ")", "return", "<STR_LIT>", "stdf%I0%U0 %1, %M0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "}", "else", "if", "(", "ZERO_P", "(", "src", ")", ")", "{", "if", "(", "dbl_memory_one_insn_operand", "(", "dest", ",", "mode", ")", ")", "return", "<STR_LIT>", "std%I0%U0 %., %M0", "<STR_LIT>", ";", "return", "<STR_LIT>", "#", "<STR_LIT>", ";", "}", "}", "fatal_insn", "(", "<STR_LIT>", "bad output_move_double operand", "<STR_LIT>", ",", "insn", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "Return", "appropriate", "code", "to", "load", "up", "an", "8", "byte", "integer", "or", "floating", "point", "value" ]

[ "<STR_LIT>", ")" ]

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

[ "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_fmaddsub_ps", "(", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128", "_", "_", "B", ",", "_", "_", "m128", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_vfmaddsubps128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_", "v4sf", ")", "_", "_", "C", ",", "(" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "const", "bool", "NeedsRealignment", "=", "NumBytes", "&&", "!", "IsFunclet", "&&", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", ";", "int64_t", "RealignmentPadding", "=", "(", "NeedsRealignment", "&&", "MFI", ".", "getMaxAlign", "(", ")", ">", "Align", "(", "<NUM_LIT>", ")", ")", "?", "MFI", ".", "getMaxAlign", "(", ")", ".", "value", "(", ")", "-", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "windowsRequiresStackProbe", "(", "MF", ",", "NumBytes", "+", "RealignmentPadding", ")", ")", "{", "uint64_t", "NumWords", "=", "(", "NumBytes", "+", "RealignmentPadding", ")", ">>", "<NUM_LIT>", ";", "<FIXE>" ]

[ "if", "(", "EmitCFI", ")", "emitCalleeSavedGPRLocations", "(", "MBB", ",", "MBBI", ")", ";", "<BUGS>", "if", "(", "windowsRequiresStackProbe", "(", "MF", ",", "NumBytes", ")", ")", "{", "uint64_t", "NumWords", "=", "NumBytes", ">>", "<NUM_LIT>", ";", "<BUGE>", "if", "(", "NeedsWinCFI", ")", "{", "HasWinCFI", "=", "true", ";" ]

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

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "mem", ":", "QI", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "ior", ":", "QI", "(", "mem", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ ":", "$", "Rn", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v1i64", "(", "int_aarch64_neon_usqadd", "(", "v1i64", "FPR64", ":", "$", "Src", ")", ",", "(", "v1i64", "FPR64", ":", "$", "Rn", ")", ")", ")", ",", "(", "USQADDdd", "FPR64", ":", "$", "Src", ",", "FPR64" ]

[ "if", "(", "helper_check_signed_overflow", "(", "X", ",", "<NUM_LIT>", ")", ")", "{" ]

[ "Relocator", "::", "DWord", "A", "=", "helper_extract_movw_movt_addend", "(", "pReloc", ".", "target", "(", ")", ")", "+", "pReloc", ".", "addend", "(", ")", ";", "if", "(", "T", "!=", "<NUM_LIT>", ")", "helper_clear_thumb_bit", "(", "S", ")", ";", "Relocator", "::", "DWord", "X", "=", "(", "(", "S", "+", "A", ")", "|", "T", ")", "-", "P", ";" ]

[ "Res", ";" ]

[ "bool", "assignArg", "(", "unsigned", "ValNo", ",", "MVT", "ValVT", ",", "MVT", "LocVT", ",", "CCValAssign", "::", "LocInfo", "LocInfo", ",", "const", "CallLowering", "::", "ArgInfo", "&", "Info", ",", "ISD", "::", "ArgFlagsTy", "Flags", ",", "CCState", "&", "State", ")", "override", "{", "bool" ]

[ "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMPED", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "BREV", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "}", "return", "nullptr", ";", "}" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "if", "(", "(", "Hi", "=", "(", "Remainder", ">>", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", ")", "{" ]

[ "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "{", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "LI8", ",", "dl", ",", "MVT", "::", "i64", ",", "getI32Imm", "(", "Lo", ")", ")", ";", "}", "else", "if", "(", "Lo", ")", "{", "unsigned", "OpC", "=", "Hi", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LI8", ";", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "OpC", ",", "dl", ",", "MVT", "::", "i64", ",", "getI32Imm", "(", "Hi", ")", ")", ";", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "ORI8", ",", "dl", ",", "MVT", "::", "i64", ",", "SDValue", "(", "Result", ",", "<NUM_LIT>", ")", ",", "getI32Imm", "(", "Lo", ")", ")", ";", "}", "else", "{", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "LIS8", ",", "dl", ",", "MVT", "::", "i64", ",", "getI32Imm", "(", "Hi", ")", ")", ";", "}", "if", "(", "!", "Shift", ")", "return", "Result", ";", "if", "(", "Imm", ")", "{", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "RLDICR", ",", "dl", ",", "MVT", "::", "i64", ",", "SDValue", "(", "Result", ",", "<NUM_LIT>", ")", ",", "getI32Imm", "(", "Shift", ")", ",", "getI32Imm", "(", "<NUM_LIT>", "-", "Shift", ")", ")", ";", "}" ]

[ "Case", "(", "<STR_LIT>", "spsr_abt", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_und", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_mon", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_hyp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Default", "(", "~", "<NUM_LIT>", "U", ")", ";" ]

[ "ARMAsmParser", "::", "OperandMatchResultTy", "ARMAsmParser", "::", "parseBankedRegOperand", "(", "OperandVector", "&", "Operands", ")", "{", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "!", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "return", "MatchOperand_NoMatch", ";", "StringRef", "RegName", "=", "Tok", ".", "getString", "(", ")", ";", "unsigned", "Encoding", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ".", "lower", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "r8_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r9_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r10_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r11_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r12_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r8_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r9_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r10_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r11_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r12_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_irq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_irq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_svc", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_svc", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_abt", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_abt", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_und", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_und", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_mon", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_mon", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "elr_hyp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_hyp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_irq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_svc", "<STR_LIT>", ",", "<NUM_LIT>", ")", "." ]

[ "<FIXS>", "IRBuilder", ">", "&", "Builder", ",", "Value", "*", "Num", ",", "Value", "*", "Den", ",", "const", "FastMathFlags", "DivFMF", ",", "const", "FastMathFlags", "SqrtFMF", ",", "const", "Instruction", "*", "CtxI", ")", "const", "{", "<FIXE>" ]

[ "}", "Value", "*", "AMDGPUCodeGenPrepareImpl", "::", "optimizeWithRsq", "(", "<BUGS>", "IRBuilder", ">", "&", "Builder", ",", "Value", "*", "Num", ",", "Value", "*", "Den", ",", "FastMathFlags", "DivFMF", ",", "FastMathFlags", "SqrtFMF", ",", "const", "Instruction", "*", "CtxI", ")", "const", "{", "<BUGE>", "assert", "(", "DivFMF", ".", "allowContract", "(", ")", "&&", "SqrtFMF", ".", "allowContract", "(", ")", ")", ";" ]

[ ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ")", "{" ]

[ "unsigned", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "Value", "*", "Ptr" ]

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

[ "(", "define_reservation" ]

[ "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";" ]

[ "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "Ops", ")", ")", ";", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "Ops", ")", ")", ";", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "ReplaceNode", "(", "N", ",", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "Ops", ")", ")", ";", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{" ]

[ "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";" ]

[ "}", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "\\nFunction : ", "<STR_LIT>", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "errs", "(", ")", "<<", "<STR_LIT>", "<--------->\\n", "<STR_LIT>", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "FrameIndex : ", "<STR_LIT>", "<<", "FrameIndex", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "spOffset : ", "<STR_LIT>", "<<", "spOffset", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "stackSize : ", "<STR_LIT>", "<<", "stackSize", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "<NUM_LIT>", ";", "int", "MaxCSFI", "=", "-", "<NUM_LIT>", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ";", "}", "unsigned", "FrameReg", ";", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "Offset", ";", "Offset", "=", "spOffset", "+", "(", "int64_t", ")", "stackSize", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "Offset : ", "<STR_LIT>", "<<", "Offset", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", "<<", "<STR_LIT>", "<--------->\\n", "<STR_LIT>", ")", ";", "if", "(", "!", "MI", ".", "isDebugValue", "(", ")", "&&", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ")", "{", "assert", "(", "<STR_LIT>", "(!MI.isDebugValue() && !isInt<16>(Offset))", "<STR_LIT>", ")", ";", "}" ]

[ "_", "p", ")", "{" ]

[ "_", "_", "arm_vrev32q_m_f16", "(", "float16x8_t", "_", "_", "inactive", ",", "float16x8_t", "_", "_", "a", ",", "mve_pred16_t", "_" ]

[ "}" ]

[ "MCObjectWriter", "*", "llvm", "::", "createARM64MachObjectWriter", "(", "raw_ostream", "&", "OS", ",", "uint32_t", "CPUType", ",", "uint32_t", "CPUSubtype", ")", "{", "return", "createMachObjectWriter", "(", "new", "ARM64MachObjectWriter", "(", "CPUType", ",", "CPUSubtype", ")", ",", "OS", ",", "true", ")", ";" ]

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

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "(", ")", "const", "override", "{" ]

[ "const", "char", "*", "getPassName" ]

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

[ "(", "V1SI", "<STR_LIT>", ")", "(", "V2SI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V1DI", "<STR_LIT>", ")", "(", "V2DI", "<STR_LIT>", ")" ]

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

[ "return", "(", "uint16x4_t", ")", "_", "_", "builtin_aarch64_uqmovnv4si", "(" ]

[ "<STR_LIT>", ")" ]

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

[ "<STR_LIT>", ":" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown immediate size", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::" ]

[ ",", "opnode", ",", "VPR64", ",", "v8i16", ",", "v8i8", ",", "v8i8", ">", ";" ]

[ "def", "_8h8b", ":", "NeonI_3VDL_Ext", "<", "<NUM_LIT>", ",", "u", ",", "<NUM_LIT>", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "<FIXS>", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "unsigned", "loReg", "=", "MF", ".", "addLiveIn", "(", "NextVA", ".", "getLocReg", "(", ")", ",", "<BUGS>", "&", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ")", ";", "<BUGE>", "LoVal", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "loReg", ",", "MVT", "::", "i32", ")", ";", "}", "SDValue", "WholeValue", "=" ]

[ "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "static", "SDValue", "performVectorConvertLowCombine", "(", "SDNode", "*", "N", ",", "TargetLowering", "::", "DAGCombinerInfo", "&", "DCI", ")", "{", "auto", "&", "DAG", "=", "DCI", ".", "DAG", ";", "EVT", "ResVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "ResVT", "!=", "MVT", "::", "v2f64", ")", "return", "SDValue", "(", ")", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SINT_TO_FP", "||", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "UINT_TO_FP", ")", "{", "auto", "Extract", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Extract", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_SUBVECTOR", ")", "return", "SDValue", "(", ")", ";", "if", "(", "Extract", ".", "getValueType", "(", ")", "!=", "MVT", "::", "v2i32", ")", "return", "SDValue", "(", ")", ";", "auto", "Source", "=", "Extract", "." ]

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

[ "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "which_alternative", "=", "=", "<NUM_LIT>", "&", "&", "operands", "[", "<NUM_LIT>", "]", "!", "=", "const1_rtx", ")", "return", "<STR_LIT>", "else", "return", "<STR_LIT>", "}", "[", "(", "set_attr" ]

[ "arm_emit_eabi_attribute", "(", "<STR_LIT>", "Tag_ABI_PCS_wchar_t", "<STR_LIT>", ",", "<NUM_LIT>", ",", "wchar_size", ")", ";" ]

[ "static", "void", "arm_output_c_attributes", "(", "void", ")", "{", "int", "wchar_size", "=", "(", "int", ")", "(", "TYPE_PRECISION", "(", "wchar_type_node", ")", "/", "BITS_PER_UNIT", ")", ";" ]

[ "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "AMDGPU", "::", "IsaInfo", "::", "hasCodeObjectV3", "(", "&", "getSTI", "(", ")", ")", ")", "{", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgcn_target", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGCNTarget", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdhsa_kernel", "<STR_LIT>", ")", "return", "ParseDirectiveAMDHSAKernel", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "V3", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "else", "{", "if", "(", "IDVal", "==", "<STR_LIT>", ".hsa_code_object_version", "<STR_LIT>", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".hsa_code_object_isa", "<STR_LIT>", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amd_kernel_code_t", "<STR_LIT>", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgpu_hsa_kernel", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amd_amdgpu_isa", "<STR_LIT>", ")", "return", "ParseDirectiveISAVersion", "(", ")", ";", "if", "(", "IDVal", "==", "AMDGPU", "::", "HSAMD", "::", "AssemblerDirectiveBegin", ")", "return", "ParseDirectiveHSAMetadata", "(", ")", ";", "}", "if", "(", "IDVal", "==", "PALMD", "::", "AssemblerDirective", ")", "return", "ParseDirectivePALMetadata", "(", ")", ";", "return", "true", ";", "}" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]