Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "#", "UWDr", ")", "$", "Rn", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "round", "f64", ":", "$", "Rn", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "INST" ]

[ ";" ]

[ "Off", "-=", "<NUM_LIT>", ";", "}", "}", "MachineBasicBlock", "::", "iterator", "At", "=", "MI", ";", "if", "(", "MI", "->", "isPHI", "(", ")", ")", "At", "=", "B", ".", "getFirstNonPHI", "(", ")", ";", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "D", ",", "NewR", ")", ".", "addReg", "(", "IF", ".", "SrcR", ")", ".", "addReg", "(", "IF", ".", "InsR", ",", "<NUM_LIT>", ",", "InsS", ")", ".", "addImm", "(", "Wdh", ")", ".", "addImm", "(", "Off", ")", ";", "MRI", "->", "clearKillFlags", "(", "IF", ".", "SrcR", ")", ";", "MRI", "->", "clearKillFlags", "(", "IF", ".", "InsR", ")", ";", "}", "for", "(", "const", "auto", "&", "I", ":", "IFMap", ")", "{", "MachineInstr", "*", "DefI", "=", "MRI", "->", "getVRegDef", "(", "I", ".", "first", ")", ";", "MRI", "->", "replaceRegWith", "(", "I", ".", "first", ",", "RegMap", "[", "I", ".", "first", "]", ")", ";", "DefI", "->", "eraseFromParent", "(", ")" ]

[ "<FIXS>", "if", "(", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_vfpv2", ")", ")", "<FIXE>" ]

[ "else", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "{", "arm_pcs_default", "=", "ARM_PCS_AAPCS_VFP", ";", "<BUGS>", "if", "(", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_VFPv2", ")", ")", "<BUGE>", "error", "(", "<STR_LIT>", "-mfloat-abi=hard: selected processor lacks an FPU", "<STR_LIT>", ")", ";", "}", "else" ]

[ "}" ]

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

[ "]", ")" ]

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

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

[ "return", "(", "_", "_", "mmask8", ")", "_", "_", "builtin_ia32_pcmpeqq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_" ]

[ ";" ]

[ "else", "if", "(", "Subtarget", "->", "isPICStyleStubPIC", "(", ")", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "Result", "=", "DAG", ".", "getTargetConstantPool", "(", "CP", "->", "getConstVal", "(", ")", ",", "getPointerTy", "(", ")", ",", "CP", "->", "getAlignment", "(", ")", ",", "CP", "->", "getOffset", "(", ")", ",", "OpFlag", ")", ";", "SDLoc", "DL", "(", "CP", ")", ";", "Result", "=", "DAG", ".", "getNode", "(", "WrapperKind", ",", "DL", ",", "getPointerTy", "(", ")", ",", "Result", ")", ";", "if", "(", "OpFlag", ")", "{", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "getPointerTy", "(", ")", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ",", "Result", ")", ";", "}", "return", "Result" ]

[ "}" ]

[ "else", "{", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I0", ",", "%", "J0", ",", "%", "o0", ")", "CR_TAB", "<STR_LIT>", "st %b0,%1", "<STR_LIT>", ",", "op", ",", "plen", ",", "-", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I0", ",", "%", "J0", ",", "%", "o0", ")", ",", "op", ",", "plen", ",", "<NUM_LIT>", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";" ]

[ "}", "=", "dst", ";" ]

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

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

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_lasx_xvmaddwev_q_d", "(", "(", "v4i64", ")", "_", "<NUM_LIT>", ",", "(", "v4i64", ")", "_", "<NUM_LIT>", ",", "(", "v4i64" ]

[ "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";" ]

[ "if", "(", "llvm", "::", "is_contained", "(", "getLoadOpcodesForSpillArray", "(", ")", ",", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";" ]

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

[ "class", "CondStoreRSY", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "cls", ",", "bits", "<", "<NUM_LIT>", ">", "bytes", ",", "AddressingMode", "mode", "=", "bdaddr20only", ">", ":", "InstRSYb", "<", "opcode", ",", "(", "outs", ")", ",", "(", "ins", "cls", ":", "$", "R1", ",", "mode", ":", "$", "BD2", ",", "cond4", ":", "$", "valid", ",", "cond4", ":", "$", "M3", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "AccessBytes", "=", "bytes", ";" ]

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

[ "}", "def", ":", "InstRW", "[", "SKXWriteResGroup3", "]", ",", "(", "instregex", "<STR_LIT>", ",", "<STR_LIT>", ",", "<BUGS>", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ">", ";", "<BUGE>", "def", "SKXWriteResGroup4", ":", "SchedWriteRes", "[", "SKXPort6", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "$", "addr", ")", ")", ",", "imm", ":", "$", "lane", ")", ")", "]", ";" ]

[ "let", "Pattern", "=", "[", "(", "set", "QPR", ":", "$", "dst", ",", "(", "vector_insert", "(", "Ty", "QPR", ":", "$", "src", ")", ",", "(", "i32", "(", "LoadOp", "addrmode6", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "}", ")" ]

[ "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "DImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "DImode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "}" ]

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

[ "static", "enum", "aarch64_parse_opt_result", "aarch64_parse_arch", "(", "const", "char", "*", "to_parse", ",", "const", "struct", "processor", "*", "*", "res", ",", "uint64_t", "*", "isa_flags", ",", "std", "::", "string", "*", "invalid_extension", ")", "{", "const", "char", "*", "ext", ";", "const", "struct", "processor", "*", "arch", ";", "size_t", "len", ";", "ext", "=", "strchr", "(", "to_parse", ",", "'", "+", "'", ")", ";", "if", "(", "ext", "!=", "NULL", ")", "len", "=", "ext", "-", "to_parse", ";", "else", "len", "=", "strlen", "(", "to_parse", ")", ";", "if", "(", "len", "==", "<NUM_LIT>", ")", "return", "AARCH64_PARSE_MISSING_ARG", ";", "for", "(", "arch", "=", "all_architectures", ";", "arch", "->", "name", "!=", "NULL", ";", "arch", "++", ")", "{", "if", "(", "strlen", "(", "arch", "->", "name", ")", "==", "len", "&&", "strncmp", "(", "arch", "->", "name", ",", "to_parse", ",", "len", ")", "==", "<NUM_LIT>", ")", "{", "uint64_t", "isa_temp", "=", "arch", "->", "flags", ";", "if", "(", "ext", "!=", "NULL", ")", "{", "enum", "aarch64_parse_opt_result", "ext_res", "=", "aarch64_parse_extension", "(", "ext", ",", "&", "isa_temp", ",", "invalid_extension", ")", ";", "if", "(", "ext_res", "!=", "AARCH64_PARSE_OK", ")", "return", "ext_res", ";", "}", "*", "res", "=", "arch", ";", "*", "isa_flags", "=", "isa_temp", ";", "return", "AARCH64_PARSE_OK", ";", "}", "}", "return", "AARCH64_PARSE_INVALID_ARG", ";", "}" ]

[ "Parse", "the", "TO_PARSE", "string", "and", "put", "the", "architecture", "struct", "that", "it", "selects", "into", "RES", "and", "the", "architectural", "features", "into", "ISA_FLAGS", ".", "Return", "an", "aarch64_parse_opt_result", "describing", "the", "parse", "result", ".", "If", "there", "is", "an", "error", "parsing", ",", "RES", "and", "ISA_FLAGS", "are", "left", "unchanged", "." ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

[ "==", "PRU_ABI_TI", ";" ]

[ "return", "pru_current_abi" ]

[ "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ")", "return", "SDValue", "(", ")", ";" ]

[ "SDLoc", "DL", "(", "N", ")", ";", "auto", "MinMaxOp", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FMAXNUM", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "NoNaNsFPMath", "||", "N", "->", "getFlags", "(", ")", ".", "hasNoNaNs", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "MinMaxOp", ",", "DL", ",", "VT", ",", "Op0", ",", "Op1", ",", "N", "->", "getFlags", "(", ")", ")", ";" ]

[ ";" ]

[ "static", "bool", "mustPreserveGV", "(", "const", "GlobalValue", "&", "GV", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "&", "GV", ")", ")", "return", "F", "->", "isDeclaration", "(", ")", "||", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", "->", "getCallingConv", "(", ")", ")", ";", "GV", ".", "removeDeadConstantUsers", "(", ")" ]

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

[ "(", "set", "(", "subreg", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", "(", "clz", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")" ]

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

[ "class", "BEQC_DESC", ":", "CMP_BC_DESC_BASE", "<", "<STR_LIT>", ",", "brtarget", "," ]

[ "<STR_LIT>", ">", ",", "DwarfRegNum", "<", "[", "<NUM_LIT>", "]", ">", ";" ]

[ "def", "LB0", ":", "Ri", "<", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "SIScheduleBlock", "*", "Block", "=", "CurrentBlocks", "[", "BlockIndice", "]", ";" ]

[ "if", "(", "Block", "->", "getPreds", "(", ")", ".", "empty", "(", ")", ")", "Block", "->", "Depth", "=", "<NUM_LIT>", ";", "else", "{", "unsigned", "Depth", "=", "<NUM_LIT>", ";", "for", "(", "SIScheduleBlock", "*", "Pred", ":", "Block", "->", "getPreds", "(", ")", ")", "{", "if", "(", "Depth", "<", "Pred", "->", "Depth", "+", "Pred", "->", "getCost", "(", ")", ")", "Depth", "=", "Pred", "->", "Depth", "+", "Pred", "->", "getCost", "(", ")", ";", "}", "Block", "->", "Depth", "=", "Depth", ";", "}", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "DAGSize", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "BlockIndice", "=", "BottomUpIndex2Block", "[", "i", "]", ";" ]

[ "val", ";" ]

[ "void", "setUsesLR", "(", "bool", "val", ")", "{", "UsesLR", "=" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", ":", "SelectionDAGISel", "(", "TM", ",", "OptLevel", ")", "{", "}", "<FIXE>" ]

[ "const", "CSKYSubtarget", "*", "Subtarget", ";", "public", ":", "<BUGS>", "static", "char", "ID", ";", "<BUGE>", "explicit", "CSKYDAGToDAGISel", "(", "CSKYTargetMachine", "&", "TM", ",", "CodeGenOptLevel", "OptLevel", ")", "<BUGS>", ":", "SelectionDAGISel", "(", "ID", ",", "TM", ",", "OptLevel", ")", "{", "}", "<BUGE>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{" ]

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

[ "static", "unsigned", "computeCRSaveOffset", "(", "const", "PPCSubtarget", "&", "STI", ")", "{", "return", "(", "STI", ".", "isAIXABI", "(", ")", "&&", "!", "STI", ".", "isPPC64" ]

[ "let", "Itinerary", "=", "IIC_ScalarOp", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", "SRF", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "!", "if", "(", "hasImm", ",", "(", "ins", "SRF", ":", "$", "op1", ",", "TPCImm", "<", "i32imm", ">", ":", "$", "op2", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ",", "(", "ins", "SRF", ":", "$", "op1", ",", "SRF", ":", "$", "op2", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ")", ";" ]

[ "(", "plus", "<STR_LIT>", ")", "(", "minus", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_code_attr", "thumb1_atomic_fetch_newop_str", "[", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")" ]

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

[ "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc1", ":", "$", "op1", ",", "TPCImm", "<", "Isrc", ">", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "<NUM_LIT>", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

[ "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ ")", ")" ]

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

[ "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";" ]

[ "unsigned", "XCoreInstrInfo", "::", "InsertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "DebugLoc", "DL", ")", "const", "{", "assert", "(", "TBB", "&&", "<STR_LIT>", "InsertBranch must not be told to insert a fallthrough", "<STR_LIT>", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", "||", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Unexpected number of components!", "<STR_LIT>", ")", ";", "if", "(", "FBB", "==", "<NUM_LIT>", ")", "{", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "return", "<NUM_LIT>", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected number of components!", "<STR_LIT>", ")", ";", "unsigned", "Opc", "=", "GetCondBranchFromCond", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Cond", "[" ]

[ "$", "FRT", ",", "(", "PPCqvesplati", "v4f32", ":", "$", "FRA", ",", "(", "i32", "imm", ":", "$", "idx", ")", ")", ")", "]", ">", ";" ]

[ "def", "QVESPLATIs", ":", "Z23Form_2", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "qsrc", ":", "$", "FRT", ")", ",", "(", "ins", "qsrc", ":", "$", "FRA", ",", "u2imm", ":", "$", "idx", ")", ",", "<STR_LIT>", ",", "IIC_VecPerm", ",", "[", "(", "set", "v4f32", ":" ]

[ "_", "_", "b", ")", "{" ]

[ "vdupq_laneq_u32", "(", "uint32x4_t", "_", "_", "a", ",", "const", "int" ]

[ "}" ]

[ "bool", "AMDGPUDAGToDAGISel", "::", "isGlobalLoad", "(", "const", "LoadSDNode", "*", "N", ")", "const", "{", "if", "(", "N", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", "||", "N", "->", "getMemoryVT", "(", ")", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "return", "true", ";", "return", "checkType", "(", "N", "->", "getMemOperand", "(", ")", "->", "getValue", "(", ")", ",", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ")", ";" ]

[ "MI", ";" ]

[ "void", "ARMFrameLowering", "::", "emitPushInst", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "unsigned", "StmOpc", ",", "unsigned", "StrOpc", ",", "bool", "NoGap", ",", "bool", "(", "*", "Func", ")", "(", "unsigned", ",", "bool", ")", ",", "unsigned", "NumAlignedDPRCS2Regs", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "DL", ";", "using", "RegAndKill", "=", "std", "::", "pair", "<", "unsigned", ",", "bool", ">", ";", "SmallVector", "<", "RegAndKill", ",", "<NUM_LIT>", ">", "Regs", ";", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "while", "(", "i", "!=", "<NUM_LIT>", ")", "{", "unsigned", "LastReg", "=", "<NUM_LIT>", ";", "for", "(", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "(", "Func", ")", "(", "Reg", ",", "STI", ".", "splitFramePushPop", "(", "MF", ")", ")", ")", "continue", ";", "if", "(", "Reg", ">=", "ARM", "::", "D8", "&&", "Reg", "<", "ARM", "::", "D8", "+", "NumAlignedDPRCS2Regs", ")", "continue", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", "&&", "!", "MRI", ".", "isReserved", "(", "Reg", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "NoGap", "&&", "LastReg", "&&", "LastReg", "!=", "Reg", "-", "<NUM_LIT>", ")", "break", ";", "LastReg", "=", "Reg", ";", "Regs", ".", "push_back", "(", "std", "::", "make_pair", "(", "Reg", ",", "!", "isLiveIn", ")", ")", ";", "}", "if", "(", "Regs", ".", "empty", "(", ")", ")", "continue", ";", "std", "::", "sort", "(", "Regs", ".", "begin", "(", ")", ",", "Regs", ".", "end", "(", ")", ",", "[", "&", "]", "(", "const", "RegAndKill", "&", "LHS", ",", "const", "RegAndKill", "&", "RHS", ")", "{", "return", "TRI", ".", "getEncodingValue", "(", "LHS", ".", "first", ")", "<", "TRI", ".", "getEncodingValue", "(", "RHS", ".", "first", ")", ";", "}", ")", ";", "if", "(", "Regs", ".", "size", "(", ")", ">", "<NUM_LIT>", "||", "StrOpc", "==", "<NUM_LIT>", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StmOpc", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "setMIFlags", "(", "MIFlags", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Regs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "MIB", ".", "addReg", "(", "Regs", "[", "i", "]", ".", "first", ",", "getKillRegState", "(", "Regs", "[", "i", "]", ".", "second", ")", ")", ";", "}", "else", "if", "(", "Regs", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "Regs", "[", "<NUM_LIT>", "]", ".", "first", ",", "getKillRegState", "(", "Regs", "[", "<NUM_LIT>", "]", ".", "second", ")", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "setMIFlags", "(", "MIFlags", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "}", "Regs", ".", "clear", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", ")", "--" ]

[ "OS", "<<", "ABIFlagsSection", ";" ]

[ "MCSectionData", "&", "ABIShndxSD", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "Sec", ")", ";", "ABIShndxSD", ".", "setAlignment", "(", "<NUM_LIT>", ")", ";", "OS", ".", "SwitchSection", "(", "Sec", ")", ";" ]

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

[ "SExtVT", "=", "MVT", "::", "v32i8", ";", "break", ";", "}", ";", "SDLoc", "DL", "(", "BitCast", ")", ";", "SDValue", "V", "=", "DAG", ".", "getSExtOrTrunc", "(", "N0", ",", "DL", ",", "SExtVT", ")", ";", "if", "(", "SExtVT", "==", "MVT", "::", "v32i8", "&&", "!", "Subtarget", ".", "hasInt256", "(", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "MVT", "ShiftTy", "=", "TLI", ".", "getScalarShiftAmountTy", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Lo", "=", "extract128BitVector", "(", "V", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Hi", "=", "extract128BitVector", "(", "V", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Lo", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Hi", ")", ";", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "Hi", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "ShiftTy", ")", ")", ";", "V", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DL", ",", "MVT", "::", "i32", ",", "Lo", ",", "Hi", ")", ";", "return", "DAG", ".", "getZExtOrTrunc", "(", "V", ",", "DL", ",", "VT", ")", ";", "}", "if", "(", "SExtVT", "==", "MVT", "::", "v8i16", ")", "{", "V", "=", "DAG", ".", "getBitcast", "(", "MVT", "::", "v16i8", ",", "V", ")", ";", "V", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v16i8", ",", "DL", ",", "V", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v16i8", ")", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ")", ";", "}", "else", "assert", "(", "SExtVT", ".", "getScalarType", "(", ")", "!=", "MVT", "::", "i16", "&&", "<STR_LIT>", "Vectors of i16 must be shuffled" ]

[ "::", "i32", ")", ")", ";" ]

[ "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Sub", ",", "TrueVal", ",", "ARMcc", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CPSRGlue", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "FalseVal", "=", "Sub", ";", "}", "}", "else", "if", "(", "isNullConstant", "(", "TrueVal", ")", ")", "{", "if", "(", "CC", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "isNullConstant", "(", "RHS", ")", "&&", "(", "!", "Subtarget", "->", "isThumb1Only", "(", ")", "||", "isPowerOf2Constant", "(", "FalseVal", ")", ")", ")", "{", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "i32", ")", ",", "LHS", ",", "RHS", ")", ";", "SDValue", "CPSRGlue", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "ARM", "::", "CPSR", ",", "Sub", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "SDValue", "(", ")", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Sub", ",", "FalseVal", ",", "DAG", ".", "getConstant", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CPSRGlue", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "FalseVal", "=", "Sub", ";", "}", "}", "const", "APInt", "*", "TrueConst", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", "&&", "CC", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "(", "FalseVal", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "(", "FalseVal", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "LHS", ")", "&&", "(", "FalseVal", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "RHS", ")", "&&", "(", "TrueConst", "=", "isPowerOf2Constant", "(", "TrueVal", ")", ")", ")", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "i32", ")", ";", "unsigned", "ShiftAmount", "=", "TrueConst", "->", "logBase2", "(", ")", ";", "if", "(", "ShiftAmount", ")", "TrueVal", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ";", "SDValue", "Subc", "=", "DAG", ".", "getNode", "(", "ISD", "::", "USUBO", ",", "dl", ",", "VTs", ",", "FalseVal", ",", "TrueVal", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUBCARRY", ",", "dl", ",", "VTs", ",", "FalseVal", ",", "Subc", ",", "Subc", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Carry", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "VT", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "Res", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "dl", ",", "VTs", ",", "Res", ",", "Carry", ")", ";", "if", "(", "ShiftAmount", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "dl", ",", "VT", ",", "Res", ",", "DAG", ".", "getConstant", "(", "ShiftAmount", ",", "dl", ",", "MVT" ]

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

[ "<FIXS>", "N", "->", "getOffset", "(", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "CP", "=", "DAG", ".", "getTargetConstantPool", "(", "C", ",", "MVT", "::", "i32", ",", "N", "->", "getAlignment", "(", ")", ",", "<BUGS>", "N", "->", "getOffset", "(", ")", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "CP", ")", ";", "}" ]

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

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

[ ")", "]" ]

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

[ ")" ]

[ "(", "define_int_iterator", "CRYPTO_BINARY", "[", "UNSPEC_AESD", "UNSPEC_AESE", "UNSPEC_SHA1SU1", "UNSPEC_SHA256SU0", "]" ]

[ ">", ";" ]

[ "}", "]", ">", ";", "def", "iobitposn8_XFORM", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "Log2_32", "(", "uint8_t", "(", "~", "N", "-", ">", "getZExtValue", "(", ")", ")", ")", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i16", ")", ";", "}", "]", ">", ";", "def", "ioaddr8", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "uint64_t", "val", "=", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "val", ">", "=", "<NUM_LIT>", "&", "&", "val", "<", "<NUM_LIT>", ";", "}", "]", ",", "ioaddr_XFORM", ">", ";", "def", "lowioaddr8", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "uint64_t", "val", "=", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "val", ">", "=", "<NUM_LIT>", "&", "&", "val", "<", "<NUM_LIT>", ";", "}", "]", ",", "ioaddr_XFORM", ">", ";", "def", "ioaddr16", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "uint64_t", "val", "=", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "val", ">", "=", "<NUM_LIT>", "&", "&", "val", "<", "<NUM_LIT>", ";", "}", "]", ",", "ioaddr_XFORM", ">", ";", "def", "iobitpos8", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isPowerOf2_32", "(", "uint8_t", "(", "N", "-", ">", "getZExtValue", "(", ")", ")", ")", ";", "}", "]", ",", "iobitpos8_XFORM", ">", ";", "def", "iobitposn8", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isPowerOf2_32", "(", "uint8_t", "(", "~", "N", "-", ">", "getZExtValue", "(", ")", ")", ")", ";", "}", "]", ",", "iobitposn8_XFORM" ]

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

[ "def", "A2_addh_l16_sat_hl", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "}", "else", "if", "(", "insn", "->", "vectorExtensionType", "==", "TYPE_VEX_2B", ")", "{", "<FIXE>" ]

[ "if", "(", "lFromVEX3of3", "(", "insn", "->", "vectorExtensionPrefix", "[", "<NUM_LIT>", "]", ")", ")", "attrMask", "|=", "ATTR_VEXL", ";", "<BUGS>", "}", "else", "if", "(", "insn", "->", "vectorExtensionType", "==", "TYPE_VEX_2B", ")", "{", "<BUGE>", "switch", "(", "ppFromVEX2of2", "(", "insn", "->", "vectorExtensionPrefix", "[", "<NUM_LIT>", "]", ")", ")", "{", "case", "VEX_PREFIX_66", ":", "attrMask", "|=", "ATTR_OPSIZE", ";" ]

[ "<STR_LIT>" ]

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

[ "<NUM_LIT>", ";" ]

[ "x", "=", "m68k_wrap_symbol", "(", "x", ",", "reloc", ",", "m68k_get_gp", "(", ")", ",", "temp_reg", ")", ";", "x", "=", "gen_rtx_MEM", "(", "Pmode", ",", "x", ")", ";", "MEM_READONLY_P", "(", "x", ")", "=" ]

[ "<FIXS>", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "DL", ",", "Type", ")", ";", "<FIXE>" ]

[ "EVT", "Type", "=", "Op", ".", "getValueType", "(", ")", ";", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "isInt", "<NUM_LIT>", ">", "(", "Val", ")", ")", "{", "<BUGS>", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "Type", ")", ";", "<BUGE>", "break", ";", "}", "}" ]

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

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

[ ")" ]

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

[ "<NUM_LIT>", ";" ]

[ "def", "A2_tfrt", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_2op", ">", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=" ]

[ "if", "(", "index_term_p", "(", "xfoo1", ",", "mode", ",", "strict", ")", "&&", "nonindexed_address_p", "(", "xfoo0", ",", "strict", ")", ")", "return", "true", ";" ]

[ "xfoo1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "index_term_p", "(", "xfoo0", ",", "mode", ",", "strict", ")", "&&", "nonindexed_address_p", "(", "xfoo1", ",", "strict", ")", ")", "return", "true", ";" ]

[ "return", "NO_REGS", ";" ]

[ "if", "(", "REG_P", "(", "x", ")", "&&", "(", "mode", "==", "TFmode", "||", "mode", "==", "TImode", ")", "&&", "mode", "==", "GET_MODE", "(", "x", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "x", ")", ")", "&&", "!", "TARGET_SIMD", "&&", "reg_class_subset_p", "(", "rclass", ",", "FP_REGS", ")", ")", "{", "if", "(", "mode", "==", "TFmode", ")", "sri", "->", "icode", "=", "CODE_FOR_aarch64_reload_movtf", ";", "else", "if", "(", "mode", "==", "TImode", ")", "sri", "->", "icode", "=", "CODE_FOR_aarch64_reload_movti", ";" ]

[ "<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", "prefersSlot3", "=" ]

[ "list", "=", "TREE_CHAIN", "(", "list", ")", ";" ]

[ "list", "=", "SH_ATTRIBUTES", "(", "func", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "<STR_LIT>", "function_vector", "<STR_LIT>", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "return", "true", ";" ]

[ "\\", "in_section", "=", "in_const", ";", "\\", "}", "\\", "}" ]

[ "void", "\\", "const_section", "(", ")", "\\", "{", "\\", "if", "(", "!", "USE_CONST_SECTION", ")", "\\", "text_section", "(", ")", ";", "\\", "else", "if", "(", "in_section", "!=", "in_const", ")", "\\", "{", "\\", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "%s\\n", "<STR_LIT>", ",", "CONST_SECTION_ASM_OP", ")", ";" ]

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

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "Outs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ISD", "::", "OutputArg", "Out", "=", "Outs" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MovDGUnpackAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "i8imm", ":", "$", "movdgunpack", ")", ";" ]

[ "Register", "TmpReg", "=", "MRI", "->", "createVirtualRegister", "(", "PromoteRC", ")", ";" ]

[ "case", "FlagArithMnemonic", "::", "SBB", ":", "Cond", "=", "X86", "::", "COND_B", ";", "Addend", "=", "<NUM_LIT>", ";", "break", ";", "case", "FlagArithMnemonic", "::", "ADOX", ":", "Cond", "=", "X86", "::", "COND_O", ";", "Addend", "=", "<NUM_LIT>", ";", "break", ";", "}", "unsigned", "&", "CondReg", "=", "CondRegs", "[", "Cond", "]", ";", "if", "(", "!", "CondReg", ")", "CondReg", "=", "promoteCondToReg", "(", "TestMBB", ",", "TestPos", ",", "TestLoc", ",", "Cond", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";" ]

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

[ "static", "const", "char", "*", "avr_out_movqi_r_mr_reg_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "<NUM_LIT>", "]", ";", "rtx", "src", "=", "op", "[", "<NUM_LIT>", "]", ";", "rtx", "x", "=", "XEXP", "(", "src", ",", "<NUM_LIT>", ")", ";", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "<STR_LIT>", "ld %0,%b1", "<STR_LIT>" ]

[ "return", "Eval", "&&", "!", "RC", ".", "isBottom", "(", ")", ";" ]

[ "RC", "=", "L", ";", "return", "!", "RC", ".", "isBottom", "(", ")", ";", "}", "bool", "Eval", "=", "evaluate", "(", "R", ",", "L", ",", "RC", ")", ";" ]

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

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

[ "break", ";" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown overflow instruction!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "SADDO", ":", "ARMcc", "=", "DAG", ".", "getConstant", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "Value", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ")", ";", "OverflowCmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "Glue", ",", "Value", ",", "LHS", ")", ";", "break", ";", "case", "ISD", "::", "UADDO", ":", "ARMcc", "=", "DAG", ".", "getConstant", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "Value", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SDLoc", "(", "Op", ")", ",", "Op", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ")", ";", "OverflowCmp", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "Glue", ",", "Value", ",", "LHS", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_pandf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_3op", ">", ",", "Enc_ea4c54", ",", "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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "xor", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "SI", "(", "post_inc", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", ")", ")", ")", "]", "<STR_LIT>" ]

[ "=", "Imm", ";" ]

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

[ "<FIXS>", "TS", ".", "emitTCEntry", "(", "*", "S", ")", ";", "<FIXE>" ]

[ "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "MCSymbol", "*", "S", "=", "OutContext", ".", "GetOrCreateSymbol", "(", "I", "->", "first", "->", "getName", "(", ")", ")", ";", "<BUGS>", "OutStreamer", ".", "EmitTCEntry", "(", "*", "S", ")", ";", "<BUGE>", "}", "}", "new", "file", "mode", "<NUM_LIT>" ]

[ "<FIXS>", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MEMBARRIER", ",", "DL", ",", "MVT", "::", "Other", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "SDValue", "XCoreTargetLowering", "::", "LowerATOMIC_FENCE", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "<BUGS>", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}", "SDValue", "XCoreTargetLowering", "::" ]

[ "void", "ia64_vms_output_aligned_decl_common", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "tree", "attr", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "if", "(", "attr", ")", "attr", "=", "lookup_attribute", "(", "<STR_LIT>", "common_object", "<STR_LIT>", ",", "attr", ")", ";", "if", "(", "attr", ")", "{", "tree", "id", "=", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ";", "const", "char", "*", "name", ";", "if", "(", "TREE_CODE", "(", "id", ")", "==", "IDENTIFIER_NODE", ")", "name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "else", "if", "(", "TREE_CODE", "(", "id", ")", "==", "STRING_CST", ")", "name", "=", "TREE_STRING_POINTER", "(", "id", ")", ";", "else", "abort", "(", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t.vms_common\\t\\\"%s\\\",", "<STR_LIT>", ",", "name", ")", ";", "}", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "COMMON_ASM_OP", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", ",", "<STR_LIT>", "HOST_WIDE_INT_PRINT_UNSIGNED", "<STR_LIT>", ",%u", "<STR_LIT>", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "fputc", "(", "'", "\\n", "'", ",", "file", ")", ";", "}" ]

[ "Part", "of", "the", "low", "level", "implementation", "of", "DEC", "Ada", "pragma", "Common_Object", "." ]

[ "*", "MF", ")", "const", "{" ]

[ "const", "uint16_t", "*", "NyuziRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction" ]

[ "machine", "->", "is_naked", "&&", "!", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", ";" ]

[ "return", "(", "!", "frame_pointer_needed", "&&", "get_frame_size", "(", ")", "==", "<NUM_LIT>", "&&", "avr_outgoing_args_size", "(", ")", "==", "<NUM_LIT>", "&&", "avr_regs_to_save", "(", "NULL", ")", "==", "<NUM_LIT>", "&&", "!", "cfun", "->", "machine", "->", "is_interrupt", "&&", "!", "cfun", "->", "machine", "->", "is_signal", "&&", "!", "cfun", "->" ]

[ "}" ]

[ "if", "(", "static_cast", "<", "int32_t", ">", "(", "OldOpnd", "->", "getImm", "(", ")", ")", "==", "std", "::", "numeric_limits", "<", "int32_t", ">", "::", "max", "(", ")", ")", "return", "true", ";", "break", ";", "case", "AMDGPU", "::", "V_MAX_I32_e32", ":", "case", "AMDGPU", "::", "V_MAX_I32_e64", ":", "if", "(", "static_cast", "<", "int32_t", ">", "(", "OldOpnd", "->", "getImm", "(", ")", ")", "==", "std", "::", "numeric_limits", "<", "int32_t", ">", "::", "min", "(", ")", ")", "return", "true", ";", "break", ";", "case", "AMDGPU", "::", "V_MUL_I32_I24_e32", ":", "case", "AMDGPU", "::", "V_MUL_I32_I24_e64", ":", "case", "AMDGPU", "::", "V_MUL_U32_U24_e32", ":", "case", "AMDGPU", "::", "V_MUL_U32_U24_e64", ":", "if", "(", "OldOpnd", "->", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "return", "true", ";", "break", ";", "}", "return", "false", ";" ]

[ "(", "v16i8", "MQPR", ":", "$", "val2", ")", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "add", "(", "ARMVMLAVu", "(", "v16i8", "MQPR", ":", "$", "val1", ")", ",", "(", "v16i8", "MQPR", ":", "$", "val2", ")", ")", ",", "tGPREven", ":", "$", "Rd", ")", ")", ",", "(", "i32", "(", "MVE_VMLADAVau8", "tGPREven", ":", "$", "Rd", ",", "(", "v16i8", "MQPR", ":", "$", "val1", ")", "," ]

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

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>" ]

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

[ "def", "A4_psxtbt", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "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>", ";" ]

[ "case", "X86", "::", "SUB8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "SUB8i8", ")", ";", "break", ";" ]

[ "case", "X86", "::", "JAE_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JAE_1", ")", ";", "break", ";", "case", "X86", "::", "JE_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JE_1", ")", ";", "break", ";", "case", "X86", "::", "JNE_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JNE_1", ")", ";", "break", ";", "case", "X86", "::", "JBE_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JBE_1", ")", ";", "break", ";", "case", "X86", "::", "JA_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JA_1", ")", ";", "break", ";", "case", "X86", "::", "JS_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JS_1", ")", ";", "break", ";", "case", "X86", "::", "JNS_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JNS_1", ")", ";", "break", ";", "case", "X86", "::", "JP_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JP_1", ")", ";", "break", ";", "case", "X86", "::", "JNP_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JNP_1", ")", ";", "break", ";", "case", "X86", "::", "JL_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JL_1", ")", ";", "break", ";", "case", "X86", "::", "JGE_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JGE_1", ")", ";", "break", ";", "case", "X86", "::", "JLE_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JLE_1", ")", ";", "break", ";", "case", "X86", "::", "JG_4", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "JG_1", ")", ";", "break", ";", "case", "X86", "::", "ACQUIRE_MOV8rm", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV8rm", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "ACQUIRE_MOV16rm", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV16rm", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "ACQUIRE_MOV32rm", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV32rm", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "ACQUIRE_MOV64rm", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV64rm", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "RELEASE_MOV8mr", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV8mr", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "RELEASE_MOV16mr", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV16mr", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "RELEASE_MOV32mr", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV32mr", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "RELEASE_MOV64mr", ":", "OutMI", ".", "setOpcode", "(", "X86", "::", "MOV64mr", ")", ";", "goto", "ReSimplify", ";", "case", "X86", "::", "MOV8mr_NOREX", ":", "case", "X86", "::", "MOV8mr", ":", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "X86", "::", "MOV8ao8", ")", ";", "break", ";", "case", "X86", "::", "MOV8rm_NOREX", ":", "case", "X86", "::", "MOV8rm", ":", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "X86", "::", "MOV8o8a", ")", ";", "break", ";", "case", "X86", "::", "MOV16mr", ":", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "X86", "::", "MOV16ao16", ")", ";", "break", ";", "case", "X86", "::", "MOV16rm", ":", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "X86", "::", "MOV16o16a", ")", ";", "break", ";", "case", "X86", "::", "MOV32mr", ":", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "X86", "::", "MOV32ao32", ")", ";", "break", ";", "case", "X86", "::", "MOV32rm", ":", "SimplifyShortMoveForm", "(", "AsmPrinter", ",", "OutMI", ",", "X86", "::", "MOV32o32a", ")", ";", "break", ";", "case", "X86", "::", "ADC8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADC8i8", ")", ";", "break", ";", "case", "X86", "::", "ADC16ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADC16i16", ")", ";", "break", ";", "case", "X86", "::", "ADC32ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADC32i32", ")", ";", "break", ";", "case", "X86", "::", "ADC64ri32", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADC64i32", ")", ";", "break", ";", "case", "X86", "::", "ADD8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADD8i8", ")", ";", "break", ";", "case", "X86", "::", "ADD16ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADD16i16", ")", ";", "break", ";", "case", "X86", "::", "ADD32ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADD32i32", ")", ";", "break", ";", "case", "X86", "::", "ADD64ri32", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "ADD64i32", ")", ";", "break", ";", "case", "X86", "::", "AND8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "AND8i8", ")", ";", "break", ";", "case", "X86", "::", "AND16ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "AND16i16", ")", ";", "break", ";", "case", "X86", "::", "AND32ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "AND32i32", ")", ";", "break", ";", "case", "X86", "::", "AND64ri32", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "AND64i32", ")", ";", "break", ";", "case", "X86", "::", "CMP8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "CMP8i8", ")", ";", "break", ";", "case", "X86", "::", "CMP16ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "CMP16i16", ")", ";", "break", ";", "case", "X86", "::", "CMP32ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "CMP32i32", ")", ";", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "CMP64i32", ")", ";", "break", ";", "case", "X86", "::", "OR8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "OR8i8", ")", ";", "break", ";", "case", "X86", "::", "OR16ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "OR16i16", ")", ";", "break", ";", "case", "X86", "::", "OR32ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "OR32i32", ")", ";", "break", ";", "case", "X86", "::", "OR64ri32", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "OR64i32", ")", ";", "break", ";", "case", "X86", "::", "SBB8ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "SBB8i8", ")", ";", "break", ";", "case", "X86", "::", "SBB16ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "SBB16i16", ")", ";", "break", ";", "case", "X86", "::", "SBB32ri", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "SBB32i32", ")", ";", "break", ";", "case", "X86", "::", "SBB64ri32", ":", "SimplifyShortImmForm", "(", "OutMI", ",", "X86", "::", "SBB64i32", ")", ";", "break", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_popcnt_epi32", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m256i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_vpopcountd_v8si_mask", "(", "(", "_", "_", "v8si", ")", "_", "_", "A", ",", "(", "_", "_", "v8si", ")", "_", "mm256_setzero_si256", "(", ")", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ")", ";" ]

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

[ "(", "define_int_attr", "brk_reg_opno", "[", "(", "UNSPEC_BRKN", "<STR_LIT>", ")", "(", "UNSPEC_BRKPA", "<STR_LIT>", ")", "(", "UNSPEC_BRKPB", "<STR_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_inserti64x2", "(", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_inserti64x2_256_mask", "(", "(", "_", "_", "v4di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")", "_", "_", "B", ",", "_", "_", "imm", ",", "(", "_", "_", "v4di", ")", "_", "mm256_setzero_si256", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "nullptr", ";" ]

[ "}", "auto", "I", "=", "std", "::", "lower_bound", "(", "std", "::", "begin", "(", "NEONLdStTable", ")", ",", "std", "::", "end", "(", "NEONLdStTable", ")", ",", "Opcode", ")", ";", "if", "(", "I", "!=", "std", "::", "end", "(", "NEONLdStTable", ")", "&&", "I", "->", "PseudoOpc", "==", "Opcode", ")", "return", "I", ";", "return" ]

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

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

[ "let", "isExtendable", "=", "<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", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "n1", ";" ]

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

[ "(", "MF", ")", ":", "MCG", ".", "getUnknownNode", "(", "T", ")", ")", ";" ]

[ "Type", "*", "T", "=", "NULL", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "F", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "M", ".", "getNamedValue", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "}", "if", "(", "j", "->", "hasOneMemOperand", "(", ")", ")", "{", "const", "Value", "*", "Callee", "=", "(", "*", "j", "->", "memoperands_begin", "(", ")", ")", "->", "getValue", "(", ")", ";", "T", "=", "Callee", "?", "Callee", "->", "getType", "(", ")", ":", "NULL", ";", "}", "MachineFunction", "*", "MF", "=", "F", "?", "MMI", ".", "getMachineFunction", "(", "F", ")", ":", "NULL", ";", "MCG", ".", "makeMCGSite", "(", "MCGN", ",", "j", ",", "MF", "?", "MCG", ".", "makeMCGNode" ]

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

[ "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ",", "<NUM_LIT>", ")", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_cvtt_roundpd_epi64", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_cvttpd2qq512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8di", ")", "_", "mm512_setzero_si512", "(", ")" ]

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

[ "CommentString", "=", "<STR_LIT>", ";", "<STR_LIT>", ";", "ExceptionsType", "=", "ExceptionHandling", "::", "Dwarf", ";", "if", "(", "!", "is64Bit", ")", "Data64bitsDirective", "=", "<NUM_LIT>", ";" ]

[ "void", "ARMInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "MOVs", ")", "{", "const", "MCOperand", "&", "Dst", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MCOperand", "&", "MO1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MCOperand", "&", "MO2", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MCOperand", "&", "MO3", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "O", "<<", "'", "\\t", "'", "<<", "<STR_LIT>", "::", "<STR_LIT>", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO3", ".", "getImm", "(", ")", ")", ")", ";", "printSBitModifierOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "printPredicateOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", "\\t", "'", "<<", "getRegisterName", "(", "Dst", ".", "getReg", "(", ")", ")", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "getRegisterName", "(", "MO1", ".", "getReg", "(", ")", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO3", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "if", "(", "MO2", ".", "getReg", "(", ")", ")", "{", "O", "<<", "getRegisterName", "(", "MO2", ".", "getReg", "(", ")", ")", ";", "assert", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO3", ".", "getImm", "(", ")", ")", "==", "<NUM_LIT>", ")", ";", "}", "else", "{", "O", "<<", "<STR_LIT>", "#", "<STR_LIT>", "<<", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO3", ".", "getImm", "(", ")", ")", ";", "}", "return", ";", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "STM_UPD", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2STM_UPD", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "{", "const", "MCOperand", "&", "MO1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO1", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "O", "<<", "'", "\\t", "'", "<<", "<STR_LIT>", "push", "<STR_LIT>", ";", "printPredicateOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", "\\t", "'", ";", "printRegisterList", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "return", ";", "}", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "LDM_UPD", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2LDM_UPD", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "{", "const", "MCOperand", "&", "MO1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO1", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "O", "<<", "'", "\\t", "'", "<<", "<STR_LIT>", "pop", "<STR_LIT>", ";", "printPredicateOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", "\\t", "'", ";", "printRegisterList", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "return", ";", "}", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VSTMS_UPD", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VSTMD_UPD", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "{", "const", "MCOperand", "&", "MO1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO1", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "O", "<<", "'", "\\t", "'", "<<", "<STR_LIT>", "vpush", "<STR_LIT>", ";", "printPredicateOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", "\\t", "'", ";", "printRegisterList", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "return", ";", "}", "}", "if", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VLDMS_UPD", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VLDMD_UPD", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "{", "const", "MCOperand", "&", "MO1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "MO1", ".", "getImm", "(", ")", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "O", "<<", "'", "\\t", "'", "<<", "<STR_LIT>", "vpop", "<STR_LIT>", ";", "printPredicateOperand", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "O", "<<", "'", "\\t", "'", ";", "printRegisterList", "(", "MI", ",", "<NUM_LIT>", ",", "O", ")", ";", "return", ";", "}", "}", "printInstruction", "(", "MI", ",", "O", ")", ";", "}" ]

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

[ "}" ]

[ "def", "vecshiftR16", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "Imm1_16Operand", ";" ]

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

[ "return", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>" ]

[ "location", ",", "<STR_LIT>", "too few arguments to function %qE", "<STR_LIT>", ",", "fndecl", ")", ";" ]

[ "if", "(", "m_arglist", ".", "length", "(", ")", "<", "expected", ")", "error_at", "(" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "VX", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_duplicate", ":", "VX", "(", "match_operand", ":", "<", "V_elem", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "::", "S_MOV_B64", ";" ]

[ "MCPhysReg", "TmpVGPR", "=", "findScratchNonCalleeSaveRegister", "(", "MRI", ",", "LiveRegs", ",", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "if", "(", "!", "TmpVGPR", ")", "report_fatal_error", "(", "<STR_LIT>", "failed to find free scratch register", "<STR_LIT>", ")", ";", "buildEpilogRestore", "(", "ST", ",", "TRI", ",", "*", "FuncInfo", ",", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "TmpVGPR", ",", "FramePtrFI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "FramePtrReg", ")", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "assert", "(", "MFI", ".", "getStackID", "(", "FramePtrFI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "ArrayRef", "<", "SIMachineFunctionInfo", "::", "SpilledReg", ">", "Spill", "=", "FuncInfo", "->", "getSGPRToVGPRSpills", "(", "FramePtrFI", ")", ";", "assert", "(", "Spill", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READLANE_B32", ")", ",", "FramePtrReg", ")", ".", "addReg", "(", "Spill", "[", "<NUM_LIT>", "]", ".", "VGPR", ")", ".", "addImm", "(", "Spill", "[", "<NUM_LIT>", "]", ".", "Lane", ")", ";", "}", "}", "const", "bool", "needsFrameMoves", "=", "true", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "needsFrameMoves", ")", "buildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createDefCfaRegister", "(", "nullptr", ",", "MCRI", "->", "getDwarfRegNum", "(", "StackPtrReg", ",", "false", ")", ")", ")", ";", "}", "if", "(", "BPSaveIndex", ")", "{", "const", "int", "BasePtrFI", "=", "*", "BPSaveIndex", ";", "assert", "(", "!", "MFI", ".", "isDeadObjectIndex", "(", "BasePtrFI", ")", ")", ";", "if", "(", "spilledToMemory", "(", "MF", ",", "BasePtrFI", ")", ")", "{", "initLiveRegs", "(", "LiveRegs", ",", "TRI", ",", "FuncInfo", ",", "MF", ",", "MBB", ",", "MBBI", ",", "false", ")", ";", "MCPhysReg", "TmpVGPR", "=", "findScratchNonCalleeSaveRegister", "(", "MRI", ",", "LiveRegs", ",", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "if", "(", "!", "TmpVGPR", ")", "report_fatal_error", "(", "<STR_LIT>", "failed to find free scratch register", "<STR_LIT>", ")", ";", "buildEpilogRestore", "(", "ST", ",", "TRI", ",", "*", "FuncInfo", ",", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "TmpVGPR", ",", "BasePtrFI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "BasePtrReg", ")", ".", "addReg", "(", "TmpVGPR", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "assert", "(", "MFI", ".", "getStackID", "(", "BasePtrFI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "ArrayRef", "<", "SIMachineFunctionInfo", "::", "SpilledReg", ">", "Spill", "=", "FuncInfo", "->", "getSGPRToVGPRSpills", "(", "BasePtrFI", ")", ";", "assert", "(", "Spill", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_READLANE_B32", ")", ",", "BasePtrReg", ")", ".", "addReg", "(", "Spill", "[", "<NUM_LIT>", "]", ".", "VGPR", ")", ".", "addImm", "(", "Spill", "[", "<NUM_LIT>", "]", ".", "Lane", ")", ";", "}", "}", "Register", "ScratchExecCopy", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ")", "continue", ";", "if", "(", "!", "ScratchExecCopy", ")", "ScratchExecCopy", "=", "buildScratchExecCopy", "(", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "false", ")", ";", "buildEpilogRestore", "(", "ST", ",", "TRI", ",", "*", "FuncInfo", ",", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "*", "Reg", ".", "FI", ")", ";", "}", "for", "(", "const", "auto", "&", "Reg", ":", "FuncInfo", "->", "WWMReservedRegs", ")", "{", "auto", "VGPR", "=", "Reg", ".", "first", ";", "auto", "FI", "=", "Reg", ".", "second", ";", "if", "(", "!", "FI", ")", "continue", ";", "if", "(", "!", "ScratchExecCopy", ")", "ScratchExecCopy", "=", "buildScratchExecCopy", "(", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "false", ")", ";", "buildEpilogRestore", "(", "ST", ",", "TRI", ",", "*", "FuncInfo", ",", "LiveRegs", ",", "MF", ",", "MBB", ",", "MBBI", ",", "VGPR", ",", "*", "FI", ")", ";", "}", "if", "(", "ScratchExecCopy", ")", "{", "unsigned", "ExecMov", "=", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32", ":", "AMDGPU" ]

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

[ "}", "def", "VST1LNd16", ":", "VST1LN", "<NUM_LIT>", ",", "{", "?", ",", "?", ",", "<NUM_LIT>", ",", "?", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "<BUGS>", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "addr", "{", "<NUM_LIT>", "}", ";", "<BUGE>", "}", "def", "VST1LNd32", ":", "VST1LN", "<NUM_LIT>", ",", "{", "?", ",", "<NUM_LIT>", ",", "?", ",", "?", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "}", ";", "<BUGS>", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "addr", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "<BUGE>", "}", "def", "VST1LNq8Pseudo", ":", "VSTQLNPseudo", "IIC_VST1ln", ">", ";" ]