Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "bool", "SPIRVInstrInfo", "::", "isConstantInstr", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "}" ]

[ "static", "unsigned", "getWFCountLimitedByGPR", "(", "unsigned", "GPRCount", ")", "{", "assert", "(", "GPRCount", "&&", "<STR_LIT>", "GPRCount cannot be 0", "<STR_LIT>", ")", ";", "return", "<NUM_LIT>", "/", "GPRCount", ";" ]

[ "<FIXS>", "rl78_alloc_physical_registers_umul", "(", "rtx_insn", "*", "insn", ")", "<FIXE>" ]

[ "static", "void", "<BUGS>", "rl78_alloc_physical_registers_umul", "(", "rtx", "insn", ")", "<BUGE>", "{", "rtx", "prev", "=", "prev_nonnote_nondebug_insn", "(", "insn", ")", ";", "rtx", "first", ";" ]

[ "dst2", ";" ]

[ "class", "StoreExclusivePair", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "o2", ",", "bit", "L", ",", "bit", "o1", ",", "bit", "o0", ",", "RegisterClass", "regtype", ",", "string", "asm", ">", ":", "BaseLoadStoreExclusive", "<", "sz", ",", "o2", ",", "L", ",", "o1", ",", "o0", ",", "(", "outs", "GPR32", ":", "$", "Ws", ")", ",", "(", "ins", "regtype", ":", "$", "Rt", ",", "regtype", ":", "$", "Rt2", ",", "am_noindex", ":", "$", "addr", ")", ",", "asm", ",", "<STR_LIT>", ">", ",", "Sched", "<", "[", "WriteSTX", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "status", ";", "bits", "<", "<NUM_LIT>", ">", "dst1", ";", "bits", "<", "<NUM_LIT>", ">", "dst2", ";", "bits", "<", "<NUM_LIT>", ">", "base", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "status", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ ")", ";" ]

[ "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AZ", ")", ";", "Reserved", ".", "set", "(", "AN", ")", ";", "Reserved", ".", "set", "(", "AQ", ")", ";", "Reserved", ".", "set", "(", "AC0", ")", ";", "Reserved", ".", "set", "(", "AC1", ")", ";", "Reserved", ".", "set", "(", "AV0", ")", ";", "Reserved", ".", "set", "(", "AV0S", ")", ";", "Reserved", ".", "set", "(", "AV1", ")", ";", "Reserved", ".", "set", "(", "AV1S", ")", ";", "Reserved", ".", "set", "(", "V", ")", ";", "Reserved", ".", "set", "(", "VS", ")", ";", "Reserved", ".", "set", "(", "CYCLES", ")", ".", "set", "(", "CYCLES2", ")", ";", "Reserved", ".", "set", "(", "L0", ")", ";", "Reserved", ".", "set", "(", "L1", ")", ";", "Reserved", ".", "set", "(", "L2", ")", ";", "Reserved", ".", "set", "(", "L3", ")", ";", "Reserved", ".", "set", "(", "SP" ]

[ "RPI", ".", "Offset", "=", "Offset", "/", "Scale", ";" ]

[ "}", "if", "(", "(", "RPI", ".", "Reg1", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "RPI", ".", "Reg2", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "ShadowCallStack", ")", ")", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isXRegisterReserved", "(", "<NUM_LIT>", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Must reserve x18 to use shadow call stack", "<STR_LIT>", ")", ";", "NeedShadowCallStackProlog", "=", "true", ";", "}", "assert", "(", "(", "!", "RPI", ".", "isPaired", "(", ")", "||", "(", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", "+", "<NUM_LIT>", "==", "CSI", "[", "i", "+", "<NUM_LIT>", "]", ".", "getFrameIdx", "(", ")", ")", ")", "&&", "<STR_LIT>", "Out of order callee saved regs!", "<STR_LIT>", ")", ";", "assert", "(", "(", "!", "RPI", ".", "isPaired", "(", ")", "||", "!", "NeedsFrameRecord", "||", "RPI", ".", "Reg2", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "RPI", ".", "Reg1", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "<STR_LIT>", "FrameRecord must be allocated together with LR", "<STR_LIT>", ")", ";", "assert", "(", "(", "!", "RPI", ".", "isPaired", "(", ")", "||", "!", "NeedsFrameRecord", "||", "RPI", ".", "Reg1", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "RPI", ".", "Reg2", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "<STR_LIT>", "FrameRecord must be allocated together with LR", "<STR_LIT>", ")", ";", "assert", "(", "(", "!", "produceCompactUnwindFrame", "(", "MF", ")", "||", "CC", "==", "CallingConv", "::", "PreserveMost", "||", "(", "RPI", ".", "isPaired", "(", ")", "&&", "(", "(", "RPI", ".", "Reg1", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "RPI", ".", "Reg2", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "RPI", ".", "Reg1", "+", "<NUM_LIT>", "==", "RPI", ".", "Reg2", ")", ")", ")", "&&", "<STR_LIT>", "Callee-save registers not saved as adjacent register pair!", "<STR_LIT>", ")", ";", "RPI", ".", "FrameIdx", "=", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ";", "int", "Scale", "=", "RPI", ".", "getScale", "(", ")", ";", "if", "(", "RPI", ".", "isScalable", "(", ")", ")", "ScalableByteOffset", "-=", "Scale", ";", "else", "ByteOffset", "-=", "RPI", ".", "isPaired", "(", ")", "?", "<NUM_LIT>", "*", "Scale", ":", "Scale", ";", "assert", "(", "!", "(", "RPI", ".", "isScalable", "(", ")", "&&", "RPI", ".", "isPaired", "(", ")", ")", "&&", "<STR_LIT>", "Paired spill/fill instructions don't exist for SVE vectors", "<STR_LIT>", ")", ";", "if", "(", "AFI", "->", "hasCalleeSaveStackFreeSpace", "(", ")", "&&", "!", "FixupDone", "&&", "!", "RPI", ".", "isScalable", "(", ")", "&&", "RPI", ".", "Type", "!=", "RegPairInfo", "::", "FPR128", "&&", "!", "RPI", ".", "isPaired", "(", ")", ")", "{", "FixupDone", "=", "true", ";", "ByteOffset", "-=", "<NUM_LIT>", ";", "assert", "(", "ByteOffset", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", ";", "assert", "(", "MFI", ".", "getObjectAlign", "(", "RPI", ".", "FrameIdx", ")", "<=", "Align", "(", "<NUM_LIT>", ")", ")", ";", "MFI", ".", "setObjectAlignment", "(", "RPI", ".", "FrameIdx", ",", "Align", "(", "<NUM_LIT>", ")", ")", ";", "}", "int", "Offset", "=", "RPI", ".", "isScalable", "(", ")", "?", "ScalableByteOffset", ":", "ByteOffset", ";", "assert", "(", "Offset", "%", "Scale", "==", "<NUM_LIT>", ")", ";" ]

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

[ "class", "T_load_pcr", "<", "string", "mnemonic", ",", "RegisterClass", "RC", ",", "bits", "<", "<NUM_LIT>", ">", "MajOp", ">", ":", "LDInst", "<", "(", "outs", "RC", ":", "$", "dst", ",", "IntRegs", ":", "$", "_dst_", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rz", ",", "ModRegs", ":", "$", "Mu", ")", ",", "<STR_LIT>", "#", "mnemonic", "#", "<STR_LIT>", ",", "[", "]", ",", "<STR_LIT>", ">", "{", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "Rz", ";", "bit", "Mu", ";", "let", "hasNewValue", "=", "!", "if", "(", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "RC", ")", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "{" ]

[ "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_truncate", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "Size", ";" ]

[ "size_t", "getULEBSize", "(", "int", "Value", ")", "{", "size_t", "Size", "=", "<NUM_LIT>", ";", "do", "{", "Value", ">>=", "<NUM_LIT>", ";", "Size", "+=", "sizeof", "(", "int8_t", ")", ";", "}", "while", "(", "Value", ")", ";", "return" ]

[ "}" ]

[ "static", "int", "translate_unix", "(", "char", "*", "name", ",", "int", "type", ")", "{", "strcpy", "(", "filename_buff", ",", "name", ")", ";", "return", "<NUM_LIT>", ";" ]

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

[ "return", "new", "AVRELFStreamer", "(", "S" ]

[ ",", "BWPort1", ",", "BWPort5", "]", ">", ";" ]

[ "def", "BWPort015", ":", "ProcResGroup", "<", "[", "BWPort0" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_expand_ps", "(", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_expandsf512_maskz", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "mm512_setzero_ps", "(", ")", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ")", ";" ]

[ "break", ";" ]

[ "case", "PPC", "::", "DIR_PWR9", ":", "case", "PPC", "::", "DIR_PWR10", ":", "case", "PPC", "::", "DIR_PWR11", ":", "case", "PPC", "::", "DIR_PWR_FUTURE", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "if", "(", "!", "DisableInnermostLoopAlign32", ")", "{", "if", "(", "ML", "->", "getLoopDepth", "(", ")", ">", "<NUM_LIT>", "&&", "ML", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "return", "Align", "(", "<NUM_LIT>", ")", ";", "}", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "<NUM_LIT>", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "const", "MachineInstr", "&", "J", ":", "*", "*", "I", ")", "{", "LoopSize", "+=", "TII", "->", "getInstSizeInBytes", "(", "J", ")", ";", "if", "(", "LoopSize", ">", "<NUM_LIT>", ")" ]

[ ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "match_operand", ":", "V2DF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", ")", ")", "<STR_LIT>", ")", "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ ";" ]

[ "if", "(", "Op", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ")", "return", "false", ";", "ConstantSDNode", "*", "MaskNode", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ";", "if", "(", "!", "MaskNode", ")", "return", "false", ";", "uint64_t", "AndMask", "=", "MaskNode", "->", "getZExtValue", "(", ")", ";", "if", "(", "InsertMask", "&", "AndMask", ")", "return", "false", ";", "uint64_t", "Used", "=", "allOnes", "(", "Op", ".", "getValueType", "(", ")", ".", "getSizeInBits", "(", ")", ")", ";", "if", "(", "Used", "!=", "(", "AndMask", "|", "InsertMask", ")", ")", "{", "APInt", "KnownZero", ",", "KnownOne", ";", "CurDAG", "->", "ComputeMaskedBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "if", "(", "Used", "!=", "(", "AndMask", "|", "InsertMask", "|", "KnownZero", ".", "getZExtValue", "(", ")", ")", ")", "return", "false", ";", "}", "Op", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true" ]

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

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

[ ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";" ]

[ "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "Offset", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Hi", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "Offset", "+", "<NUM_LIT>", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Lo", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "continue", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "if", "(", "VA", ".", "getLocVT", "(", ")", "!=", "MVT", "::", "f32", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "continue", ";", "}", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "i32", ",", "Arg", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "StackPtr", "=", "DAG", ".", "getRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getIntPtrConstant", "(", "VA", ".", "getLocMemOffset", "(", ")", "+", "StackOffset", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "toCallerWindow", "(", "RegsToPass", "[", "i", "]", ".", "first", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "unsigned", "SRetArgSize", "=", "(", "hasStructRetAttr", ")", "?", "getSRetArgSize", "(", "DAG", ",", "Callee", ")", ":", "<NUM_LIT>", ";", "bool", "hasReturnsTwice", "=", "hasReturnsTwiceAttr", "(", "DAG", ",", "Callee", ",", "CLI", ".", "CS", ")", ";", "unsigned", "TF", "=", "(", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "?", "SparcMCExpr", "::", "VK_Sparc_WPLT30", ":", "<NUM_LIT>", ")", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "Callee", "=", "DAG", ".", "getTargetGlobalAddress", "(", "G", "->", "getGlobal", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ",", "<NUM_LIT>", ",", "TF", ")", ";", "else", "if", "(", "ExternalSymbolSDNode", "*", "E", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "Callee", "=", "DAG", ".", "getTargetExternalSymbol", "(", "E", "->", "getSymbol", "(", ")", ",", "MVT", "::", "i32", ",", "TF", ")", ";", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "if", "(", "hasStructRetAttr", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "SRetArgSize", ",", "MVT", "::", "i32", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "toCallerWindow", "(", "RegsToPass", "[", "i", "]", ".", "first", ")", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "SparcRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "(", "(", "hasReturnsTwice", ")", "?", "TRI", "->", "getRTCallPreservedMask", "(", "CallConv", ")", ":", "TRI", "->", "getCallPreservedMask", "(", "CallConv", ")", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")" ]

[ "static", "void", "substitute_ep_register", "(", "rtx_insn", "*", "first_insn", ",", "rtx_insn", "*", "last_insn", ",", "int", "uses", ",", "int", "regno", ",", "rtx", "*", "p_r1", ",", "rtx", "*", "p_ep", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx_insn", "*", "insn", ";", "if", "(", "!", "*", "p_r1", ")", "{", "df_set_regs_ever_live", "(", "<NUM_LIT>", ",", "true", ")", ";", "*", "p_r1", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "*", "p_ep", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "}", "if", "(", "TARGET_DEBUG", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\ Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, ending at %d\\n", "<STR_LIT>", ",", "<NUM_LIT>", "*", "(", "uses", "-", "<NUM_LIT>", ")", ",", "uses", ",", "reg_names", "[", "regno", "]", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", ",", "INSN_UID", "(", "first_insn", ")", ",", "INSN_UID", "(", "last_insn", ")", ")", ";", "if", "(", "NOTE_P", "(", "first_insn", ")", ")", "first_insn", "=", "next_nonnote_insn", "(", "first_insn", ")", ";", "last_insn", "=", "next_nonnote_insn", "(", "last_insn", ")", ";", "for", "(", "insn", "=", "first_insn", ";", "insn", "&&", "insn", "!=", "last_insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "pattern", ")", "{", "rtx", "*", "p_mem", ";", "int", "unsignedp", "=", "FALSE", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pattern", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "MEM", ")", "p_mem", "=", "(", "rtx", "*", ")", "<NUM_LIT>", ";", "else", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pattern", ")", ")", "==", "MEM", ")", "p_mem", "=", "&", "SET_DEST", "(", "pattern", ")", ";", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "MEM", ")", "p_mem", "=", "&", "SET_SRC", "(", "pattern", ")", ";", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "SIGN_EXTEND", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ")", "==", "MEM", ")", "p_mem", "=", "&", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "ZERO_EXTEND", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ")", "==", "MEM", ")", "{", "p_mem", "=", "&", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "<NUM_LIT>", ")", ";", "unsignedp", "=", "TRUE", ";", "}", "else", "p_mem", "=", "(", "rtx", "*", ")", "<NUM_LIT>", ";", "if", "(", "p_mem", ")", "{", "rtx", "addr", "=", "XEXP", "(", "*", "p_mem", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", "&&", "REGNO", "(", "addr", ")", "==", "(", "unsigned", ")", "regno", ")", "*", "p_mem", "=", "change_address", "(", "*", "p_mem", ",", "VOIDmode", ",", "*", "p_ep", ")", ";", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "(", "unsigned", ")", "regno", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", "&&", "(", "(", "INTVAL", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")", "<", "ep_memory_offset", "(", "GET_MODE", "(", "*", "p_mem", ")", ",", "unsignedp", ")", ")", "&&", "(", "(", "INTVAL", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")", ">=", "<NUM_LIT>", ")", ")", "*", "p_mem", "=", "change_address", "(", "*", "p_mem", ",", "VOIDmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "*", "p_ep", ",", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")", ";", "}", "}", "}", "}", "insn", "=", "prev_nonnote_insn", "(", "first_insn", ")", ";", "if", "(", "insn", "&&", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", "==", "*", "p_ep", "&&", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", "==", "*", "p_r1", ")", "delete", "_", "insn", "(", "insn", ")", ";", "else", "emit_insn_before", "(", "gen_rtx_SET", "(", "*", "p_r1", ",", "*", "p_ep", ")", ",", "first_insn", ")", ";", "emit_insn_before", "(", "gen_rtx_SET", "(", "*", "p_ep", ",", "reg", ")", ",", "first_insn", ")", ";", "emit_insn_before", "(", "gen_rtx_SET", "(", "*", "p_ep", ",", "*", "p_r1", ")", ",", "last_insn", ")", ";", "}" ]

[ "Substitute", "memory", "references", "involving", "a", "pointer", ",", "to", "use", "the", "ep", "pointer", ",", "taking", "care", "to", "save", "and", "preserve", "the", "ep", "." ]

[ "I", "=", "MBB", ".", "end", "(", ")", ";" ]

[ "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "X86", "::", "JMP_1", ")", "{", "UnCondBrIter", "=", "I", ";", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "UnCondBrIter", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "X86", "::", "CondCode", "BranchCode", "=", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "BranchCode", "==", "X86", "::", "COND_INVALID", ")", "return", "true", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "*", "TargetBB", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "AllowModify", "&&", "UnCondBrIter", "!=", "MBB", ".", "end", "(", ")", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TargetBB", ")", ")", "{", "BranchCode", "=", "GetOppositeBranchCondition", "(", "BranchCode", ")", ";", "unsigned", "JNCC", "=", "GetCondBranchFromCond", "(", "BranchCode", ")", ";", "MachineBasicBlock", "::", "iterator", "OldInst", "=", "I", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "JNCC", ")", ")", ".", "addMBB", "(", "UnCondBrIter", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "UnCondBrIter", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "TargetBB", ")", ";", "OldInst", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "->", "eraseFromParent", "(", ")", ";", "UnCondBrIter", "=", "MBB", ".", "end", "(", ")", ";" ]

[ "(", "void", ")", "{" ]

[ "static", "void", "mkoffload_cleanup" ]

[ "::", "GPRCRegClass", ";" ]

[ "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "MI", ",", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "unsigned", "OpC", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "(", "OpC", "==", "PPC", "::", "DYNAREAOFFSET", "||", "OpC", "==", "PPC", "::", "DYNAREAOFFSET8", ")", ")", "{", "lowerDynamicAreaOffset", "(", "II", ")", ";", "return", ";", "}", "if", "(", "FPSI", "&&", "FrameIndex", "==", "FPSI", "&&", "(", "OpC", "==", "PPC", "::", "DYNALLOC", "||", "OpC", "==", "PPC", "::", "DYNALLOC8", ")", ")", "{", "lowerDynamicAlloc", "(", "II", ")", ";", "return", ";", "}", "if", "(", "OpC", "==", "PPC", "::", "SPILL_CR", ")", "{", "lowerCRSpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_CR", ")", "{", "lowerCRRestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "SPILL_CRBIT", ")", "{", "lowerCRBitSpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_CRBIT", ")", "{", "lowerCRBitRestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "SPILL_VRSAVE", ")", "{", "lowerVRSAVESpilling", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "else", "if", "(", "OpC", "==", "PPC", "::", "RESTORE_VRSAVE", ")", "{", "lowerVRSAVERestore", "(", "II", ",", "FrameIndex", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameIndex", "<", "<NUM_LIT>", "?", "getBaseRegister", "(", "MF", ")", ":", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "bool", "noImmForm", "=", "!", "MI", ".", "isInlineAsm", "(", ")", "&&", "OpC", "!=", "TargetOpcode", "::", "STACKMAP", "&&", "OpC", "!=", "TargetOpcode", "::", "PATCHPOINT", "&&", "!", "ImmToIdxMap", ".", "count", "(", "OpC", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "{", "if", "(", "!", "(", "hasBasePointer", "(", "MF", ")", "&&", "FrameIndex", "<", "<NUM_LIT>", ")", ")", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "assert", "(", "OpC", "!=", "PPC", "::", "DBG_VALUE", "&&", "<STR_LIT>", "This should be handled in a target-independent way", "<STR_LIT>", ")", ";", "bool", "OffsetFitsMnemonic", "=", "(", "OpC", "==", "PPC", "::", "EVSTDD", "||", "OpC", "==", "PPC", "::", "EVLDD", ")", "?", "isUInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ":", "isInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ";", "if", "(", "!", "noImmForm", "&&", "(", "(", "OffsetFitsMnemonic", "&&", "(", "(", "Offset", "%", "offsetMinAlign", "(", "MI", ")", ")", "==", "<NUM_LIT>", ")", ")", "||", "OpC", "==", "TargetOpcode", "::", "STACKMAP", "||", "OpC", "==", "TargetOpcode", "::", "PATCHPOINT", ")", ")", "{", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "bool", "is64Bit", "=", "TM", ".", "isPPC64", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC" ]

[ "Imm", ",", "MSB", ",", "Depth", ")", ";" ]

[ "uint64_t", "Imm", "=", "cast", "<", "const", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "uint64_t", "MSB", "=", "cast", "<", "const", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "getUsefulBitsFromBitfieldMoveOpd", "(", "Op", ",", "UsefulBits", "," ]

[ "?", "<NUM_LIT>", ":", "size", ";" ]

[ "return", "size", ">", "<NUM_LIT>", "*", "<NUM_LIT>" ]

[ "<FIXS>", "&&", "seg", "==", "ADDR_SPACE_GENERIC", ")", "<FIXE>" ]

[ "case", "UNSPEC", ":", "if", "(", "XINT", "(", "op", ",", "<NUM_LIT>", ")", "==", "UNSPEC_TP", "&&", "TARGET_TLS_DIRECT_SEG_REFS", "<BUGS>", "&&", "seg", "==", "SEG_DEFAULT", ")", "<BUGE>", "seg", "=", "DEFAULT_TLS_SEG_REG", ";", "elsereturn", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "define_mode_iterator", "SVE_FULL_HSD", "[", "VNx8HI", "VNx4SI", "VNx2DIVNx8BF", "VNx8HF", "VNx4SF", "VNx2DF", "]", ")", "<FIXE>" ]

[ "(", "define_mode_iterator", "SVE_FULL_BHSI", "[", "VNx16QI", "VNx8HI", "VNx4SI", "]", ")", "<BUGS>", "(", "define_mode_iterator", "SVE_FULL_HSD", "[", "VNx8HI", "VNx4SI", "VNx2DI", "VNx8HF", "VNx4SF", "VNx2DF", "]", ")", "<BUGE>" ]

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

[ "def", "A2_pxort", ":", "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>", ";" ]

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

[ "def", ":", "MVE_vector_offset_store_typed", "<", "v4i32", ",", "MVE_VSTRWU32_pre", "," ]

[ "}" ]

[ "static", "void", "aarch64_emit_unspec_cond_or", "(", "rtx", "target", ",", "rtx_code", "code1", ",", "rtx_code", "code2", ",", "machine_mode", "pred_mode", ",", "rtx", "ptrue", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_unspec_cond", "(", "tmp1", ",", "code1", ",", "pred_mode", ",", "ptrue", ",", "op0", ",", "op1", ")", ";", "rtx", "tmp2", "=", "gen_reg_rtx", "(", "pred_mode", ")", ";", "aarch64_emit_unspec_cond", "(", "tmp2", ",", "code2", ",", "pred_mode", ",", "ptrue", ",", "op0", ",", "op1", ")", ";", "emit_set_insn", "(", "target", ",", "gen_rtx_AND", "(", "pred_mode", ",", "gen_rtx_IOR", "(", "pred_mode", ",", "tmp1", ",", "tmp2", ")", ",", "ptrue", ")", ")", ";" ]

[ "<FIXS>", "InstrStage", "<NUM_LIT>", ",", "[", "A9_Issue0", ",", "A9_Issue1", "]", ",", "<NUM_LIT>", ">", ",", "<FIXE>" ]

[ "InstrItinData", "IIC_VMACi32D", ",", "[", "InstrStage", "<NUM_LIT>", ",", "[", "A9_DRegsN", "]", ",", "<NUM_LIT>", ",", "Required", ">", ",", "InstrStage", "<NUM_LIT>", ",", "[", "A9_DRegsVFP", "]", ",", "<NUM_LIT>", ",", "Reserved", ">", ",", "<BUGS>", "InstrStage", "<NUM_LIT>", ",", "[", "A9_Pipe1", "]", ">", ",", "<BUGE>", "InstrStage", "<NUM_LIT>", ",", "[", "A9_MUX0", "]", ",", "<NUM_LIT>", ">", ",", "InstrStage", "<NUM_LIT>", ",", "[", "A9_NPipe", "]", ">", "]", ",", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ">", "," ]

[ ")", "_", "_", "B", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "m128h", ")", "_", "_", "builtin_ia32_vfmaddsh3_maskz", "(", "(", "_", "_", "v8hf", ")", "_", "_", "W", ",", "(", "_", "_", "v8hf", ")", "_", "_", "A", ",", "-", "(", "_", "_", "v8hf" ]

[ "target", ";" ]

[ "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "if", "(", "!", "frv_check_constant_argument", "(", "icode", ",", "<NUM_LIT>", ",", "op1", ")", ")", "return", "NULL_RTX", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "<NUM_LIT>", ",", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return" ]

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

[ "_", "_", "asm", "_", "_", "volatile", "(" ]

[ "}" ]

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ ")" ]

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

[ "}" ]

[ "size_type", "empty", "(", ")", "const", "{", "return", "V", ".", "none", "(", ")", ";" ]

[ "}" ]

[ "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";" ]

[ ";" ]

[ "static", "FunctionPass", "*", "useDefaultRegisterAllocator", "(", ")", "{", "return", "nullptr" ]

[ ",", "PC", "]", ";" ]

[ "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" ]

[ "static", "void", "rs6000_secondary_reload_trace", "(", "int", "line", ",", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "rtx", "set", ",", "clobber", ";", "gcc_assert", "(", "reg", "!=", "NULL_RTX", "&&", "mem", "!=", "NULL_RTX", "&&", "scratch", "!=", "NULL_RTX", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "rs6000_secondary_reload_inner:%d, type = %s\\n", "<STR_LIT>", ",", "line", ",", "store_p", "?", "<STR_LIT>", "store", "<STR_LIT>", ":", "<STR_LIT>", "load", "<STR_LIT>", ")", ";", "if", "(", "store_p", ")", "set", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "else", "set", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "scratch", ")", ";", "debug_rtx", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "set", ",", "clobber", ")", ")", ")", ";", "}" ]

[ "Better", "tracing", "for", "rs6000_secondary_reload_inner", "." ]

[ "}" ]

[ "MVT", "::", "v2i32", ",", "MVT", "::", "v4i32", "}", ";", "for", "(", "MVT", "VT", ":", "VectorIntTypes", ")", "{", "setOperationAction", "(", "ISD", "::", "ADD", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "AND", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "OR", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SINT_TO_FP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SMUL_LOHI", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UMUL_LOHI", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIVREM", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIVREM", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ADDC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SUBC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ADDE", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SUBE", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VSELECT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "XOR", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BSWAP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ_ZERO_UNDEF", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ_ZERO_UNDEF", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "VT", ",", "Expand", ")", ";", "}", "static", "const", "MVT", "::", "SimpleValueType", "FloatVectorTypes", "[", "]", "=", "{", "MVT", "::", "v2f32", ",", "MVT", "::", "v4f32", "}", ";", "for", "(", "MVT", "VT", ":", "FloatVectorTypes", ")", "{", "setOperationAction", "(", "ISD", "::", "FABS", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMINNUM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMAXNUM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FADD", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCEIL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FDIV", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP2", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FFLOOR", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FTRUNC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMUL", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FRINT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FNEARBYINT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSQRT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSUB", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FNEG", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VSELECT", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOPYSIGN", ",", "VT", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "VT", ",", "Expand", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "FNEARBYINT", ",", "MVT", "::", "f32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FNEARBYINT", ",", "MVT", "::", "f64", ",", "Custom", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "MUL", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SELECT", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "SELECT_CC", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "STORE", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "FADD", ")", ";", "setTargetDAGCombine", "(", "ISD", "::", "FSUB", ")", ";", "setBooleanContents", "(", "ZeroOrNegativeOneBooleanContent", ")", ";", "setBooleanVectorContents", "(", "ZeroOrNegativeOneBooleanContent", ")", ";", "setSchedulingPreference", "(", "Sched", "::", "RegPressure", ")", ";", "setJumpIsExpensive", "(", "true", ")", ";", "setHasFloatingPointExceptions", "(", "false", ")", ";", "setSelectIsExpensive", "(", "false", ")", ";", "PredictableSelectIsExpensive", "=", "false", ";", "setIntDivIsCheap", "(", "false", ")", ";", "setPow2SDivIsCheap", "(", "false", ")", ";", "setFsqrtIsCheap", "(", "true", ")", ";", "MaxStoresPerMemcpy", "=", "<NUM_LIT>", ";", "MaxStoresPerMemmove", "=", "<NUM_LIT>", ";", "MaxStoresPerMemset", "=", "<NUM_LIT>", ";" ]

[ "return", "true", ";" ]

[ "}", "if", "(", "II", ".", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "x86_sse2_maskmov_dqu", ")", "return", "false", ";", "if", "(", "Value", "*", "BoolMask", "=", "getBoolVecFromMask", "(", "Mask", ")", ")", "{", "unsigned", "AddrSpace", "=", "cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getAddressSpace", "(", ")", ";", "PointerType", "*", "VecPtrTy", "=", "PointerType", "::", "get", "(", "Vec", "->", "getType", "(", ")", ",", "AddrSpace", ")", ";", "Value", "*", "PtrCast", "=", "IC", ".", "Builder", ".", "CreateBitCast", "(", "Ptr", ",", "VecPtrTy", ",", "<STR_LIT>", "castvec", "<STR_LIT>", ")", ";", "IC", ".", "Builder", ".", "CreateMaskedStore", "(", "Vec", ",", "PtrCast", ",", "Align", "(", "<NUM_LIT>", ")", ",", "BoolMask", ")", ";", "IC", ".", "eraseInstFromFunction", "(", "II", ")", ";" ]

[ "}" ]

[ "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "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>", ";", "let", "OutOfSlotData", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "Type", "*", "MemType", "=", "LI", "->", "getType", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "LI", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "<FIXE>" ]

[ "}", "<BUGS>", "<BUGE>", "TargetLowering", "::", "AtomicExpansionKindX86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "<BUGS>", "return", "needsCmpXchgNb", "(", "LI", "->", "getType", "(", ")", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "<BUGE>", "}", "TargetLowering", "::", "AtomicExpansionKind" ]

[ "false", ";" ]

[ "}", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "{", "const", "Function", "*", "Callee", "=", "I", ".", "getCalledFunction", "(", ")", ";", "const", "Type", "*", "RetTy", "=", "cast", "<", "StructType", ">", "(", "Callee", "->", "getReturnType", "(", ")", ")", "->", "getTypeAtIndex", "(", "unsigned", "(", "<NUM_LIT>", ")", ")", ";", "EVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "RetTy", ",", "VT", ")", ")", "return", "false", ";", "Value", "*", "Op1", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Value", "*", "Op2", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Reg1", "=", "getRegForValue", "(", "Op1", ")", ";", "unsigned", "Reg2", "=", "getRegForValue", "(", "Op2", ")", ";", "if", "(", "Reg1", "==", "<NUM_LIT>", "||", "Reg2", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "OpC", "=", "<NUM_LIT>", ";", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "OpC", "=", "X86", "::", "ADD32rr", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "OpC", "=", "X86", "::", "ADD64rr", ";", "else", "return" ]

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

[ "bool", "AArch64InstructionSelector", "::", "selectUnmergeValues", "(", "MachineInstr", "&", "I", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "assert", "(", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_UNMERGE_VALUES", "&&", "<STR_LIT>", "unexpected opcode", "<STR_LIT>", ")", ";", "if", "(", "RBI", ".", "getRegBank", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "TRI", ")", "->", "getID", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", "||", "RBI", ".", "getRegBank", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MRI", ",", "TRI", ")", "->", "getID", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Unmerging vector-to-gpr and scalar-to-scalar ", "<STR_LIT>", "<STR_LIT>", "currently unsupported.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "unsigned", "NumElts", "=", "I", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "unsigned", "SrcReg", "=", "I", ".", "getOperand", "(", "NumElts", ")", ".", "getReg", "(", ")", ";", "const", "LLT", "NarrowTy", "=", "MRI", ".", "getType", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "const", "LLT", "WideTy", "=", "MRI", ".", "getType", "(", "SrcReg", ")", ";", "(", "void", ")", "WideTy", ";", "assert", "(", "WideTy", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "can only unmerge from vector types!", "<STR_LIT>", ")", ";", "assert", "(", "WideTy", ".", "getSizeInBits", "(", ")", ">", "NarrowTy", ".", "getSizeInBits", "(", ")", "&&", "<STR_LIT>", "source register size too small!", "<STR_LIT>", ")", ";", "if", "(", "!", "NarrowTy", ".", "isScalar", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Vector-to-vector unmerges not supported yet.\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "unsigned", "CopyOpc", "=", "<NUM_LIT>", ";", "unsigned", "ExtractSubReg", "=", "<NUM_LIT>", ";", "switch", "(", "NarrowTy", ".", "getSizeInBits", "(", ")", ")", "{", "case", "<NUM_LIT>", ":", "CopyOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "<FIXS>", "|", "|", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "INTVAL", "(", "op", ")", "+", "<NUM_LIT>", ")", "<FIXE>" ]

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

[ "static", "void", "s390_init_frame_layout", "(", "void", ")", "{", "HOST_WIDE_INT", "frame_size", ";", "int", "base_used", ";", "int", "clobbered_regs", "[", "<NUM_LIT>", "]", ";", "if", "(", "!", "TARGET_CPU_ZARCH", ")", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "true", ";", "do", "{", "frame_size", "=", "cfun_frame_layout", ".", "frame_size", ";", "base_used", "=", "cfun", "->", "machine", "->", "split_branches_pending_p", "||", "current_function_uses_const_pool", "||", "(", "!", "DISP_IN_RANGE", "(", "-", "frame_size", ")", "&&", "!", "CONST_OK_FOR_K", "(", "-", "frame_size", ")", ")", ";", "if", "(", "!", "base_used", ")", "cfun", "->", "machine", "->", "base_reg", "=", "NULL_RTX", ";", "else", "if", "(", "current_function_is_leaf", "&&", "!", "regs_ever_live", "[", "<NUM_LIT>", "]", ")", "cfun", "->", "machine", "->", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "else", "cfun", "->", "machine", "->", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "BASE_REGNUM", ")", ";", "s390_register_info", "(", "clobbered_regs", ")", ";", "s390_frame_info", "(", ")", ";", "}", "while", "(", "frame_size", "!=", "cfun_frame_layout", ".", "frame_size", ")", ";", "}" ]

[ "Generate", "frame", "layout", ".", "Fills", "in", "register", "and", "frame", "data", "for", "the", "current", "function", "in", "cfun-", ">", "machine", ".", "This", "routine", "can", "be", "called", "multiple", "times", ";", "it", "will", "re-do", "the", "complete", "frame", "layout", "every", "time", "." ]

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

[ "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_DPAQX_S_W_PH", ")", ")", "(", "set", "(", "reg", ":", "CCDSP", "CCDSP_OU_REGNUM", ")", "(", "unspec", ":", "CCDSP", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_DPAQX_S_W_PH", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t" ]

[ "V8SI" ]

[ "(", "match_operand", ":", "V16SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "sign_extend", ":", "V8DI", "(", "vec_select", ":" ]

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

[ "let", "omod", "=", "<NUM_LIT>", ";", "let", "clamp", "=", "<NUM_LIT>", ";", "let", "last", "=", "<NUM_LIT>", ";", "let", "bank_swizzle", "=", "<NUM_LIT>", ";", "let", "pred_sel", "=", "<NUM_LIT>", ";", "let", "update_exec_mask", "=", "<NUM_LIT>", ";", "let", "update_pred", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Word0", ";" ]

[ "assert", "(", "N", ".", "getValueType", "(", ")", "==", "VT", "&&", "<STR_LIT>", "Unexpected value types", "<STR_LIT>", ")", ";" ]

[ "if", "(", "N", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", "&&", "VT", "==", "MVT", "::", "i64", ")", "return", "CurDAG", "->", "getTargetInsertSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "getUNDEF", "(", "DL", ",", "MVT", "::", "i64", ")", ",", "N", ")", ";", "if", "(", "N", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "VT", "==", "MVT", "::", "i32", ")", "return", "CurDAG", "->", "getTargetExtractSubreg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "N", ")", ";" ]

[ "false", ";" ]

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

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

[ "class", "BaseMemTagStore", "<", "bits", "<", "<NUM_LIT>", ">", "opc1", ",", "bits", "<", "<NUM_LIT>", ">", "opc2", ",", "string", "asm_insn", ",", "string", "asm_opnds", ",", "string", "cstr", ",", "dag", "oops", ",", "dag", "iops", ">", ":", "BaseMemTag", "<", "opc1", ",", "opc2", ",", "asm_insn", ",", "asm_opnds", ",", "cstr", ",", "oops", ",", "iops", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";" ]

[ ")", ";" ]

[ "df_set_flags", "(", "DF_DEFER_INSN_RESCAN", ")", ";", "regrename_init", "(", "true", ")", ";", "regrename_analyze", "(", "NULL", ")", ";", "this", "->", "analyze", "(", ")", ";", "this", "->", "rename_fma_trees", "(", ")", ";", "regrename_finish", "(" ]

[ "<STR_LIT>", ";" ]

[ "bool", "isGeneric", "(", ")", "const", "{", "return", "CPUString", "==", "<STR_LIT>", "generic" ]

[ "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsSubtarget", "&", "STI", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ";", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "TargetMachine", "&", "TM", "=", "F", ".", "getTarget", "(", ")", ";", "IsPIC", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "ABI", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ";", "LongBranchSeqSize", "=", "IsPIC", "?", "(", "(", "ABI", ".", "IsN64", "(", ")", "||", "STI", ".", "isTargetNaCl", "(", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ":", "(", "STI", ".", "hasMips32r6", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "STI", ".", "inMips16Mode", "(", ")", "||", "!", "STI", ".", "enableLongBranchPass", "(", ")", ")", "return", "false", ";", "if", "(", "IsPIC", "&&", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "int", "ShVal", "=", "STI", ".", "inMicroMipsMode", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "int64_t", "Offset", "=", "computeOffset", "(", "I", "->", "Br", ")", "/", "ShVal", ";", "if", "(", "STI", ".", "isTargetNaCl", "(", ")", ")", "{", "Offset", "*=", "<NUM_LIT>", ";", "}", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "<NUM_LIT>", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "IsPIC", ")", "{", "uint64_t", "Address", "=", "<NUM_LIT>", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "void", "SystemZHazardRecognizer", "::", "emitInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "TakenBranch", ")", "{", "SUnit", "SU", "(", "MI", ",", "<NUM_LIT>", ")", ";", "SU", ".", "isCall", "=", "MI", "->", "isCall", "(", ")", ";", "const", "MCSchedClassDesc", "*", "SC", "=", "SchedModel", "->", "resolveSchedClass", "(", "MI", ")", ";", "for", "(", "const", "MCWriteProcResEntry", "&", "PRE", ":", "make_range", "(", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ")", ")", "{", "switch", "(", "SchedModel", "->", "getProcResource", "(", "PRE", ".", "ProcResourceIdx", ")", "->", "BufferSize", ")", "{", "case", "<NUM_LIT>", ":", "SU", ".", "hasReservedResource", "=", "true", ";", "break", ";", "case", "<NUM_LIT>", ":", "SU", ".", "isUnbuffered", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "EmitInstruction", "(", "&", "SU", ")", ";", "if", "(", "TakenBranch", "&&", "CurrGroupSize", ">", "<NUM_LIT>", ")", "nextGroup", "(", "false", ")", ";", "assert", "(", "(", "!", "MI", "->", "isTerminator", "(", ")", "||", "isBranchRetTrap", "(", "MI", ")", ")", "&&", "<STR_LIT>", "Scheduler: unhandled terminator!", "<STR_LIT>", ")", ";", "}" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

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

[ "switch", "(", "MOTy", ")", "{", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "Symbol", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "Symbol", "=", "Printer", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "Symbol", "=", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "Symbol", "=", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "Symbol", "=", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "Symbol", "=", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "<unknown operand type>" ]

[ "unsigned", "CarryOpc", "=", "IsAdd", "?", "AMDGPU", "::", "S_ADDC_U32", ":", "AMDGPU", "::", "S_SUBB_U32", ";" ]

[ "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "bool", "ConsumeCarry", "=", "(", "Opcode", "==", "ISD", "::", "ADDE", "||", "Opcode", "==", "ISD", "::", "SUBE", ")", ";", "bool", "ProduceCarry", "=", "ConsumeCarry", "||", "Opcode", "==", "ISD", "::", "ADDC", "||", "Opcode", "==", "ISD", "::", "SUBC", ";", "bool", "IsAdd", "=", "Opcode", "==", "ISD", "::", "ADD", "||", "Opcode", "==", "ISD", "::", "ADDC", "||", "Opcode", "==", "ISD", "::", "ADDE", ";", "SDValue", "Sub0", "=", "CurDAG", "->", "getTargetConstant", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Sub1", "=", "CurDAG", "->", "getTargetConstant", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDNode", "*", "Lo0", "=", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "MVT", "::", "i32", ",", "LHS", ",", "Sub0", ")", ";", "SDNode", "*", "Hi0", "=", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "MVT", "::", "i32", ",", "LHS", ",", "Sub1", ")", ";", "SDNode", "*", "Lo1", "=", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "MVT", "::", "i32", ",", "RHS", ",", "Sub0", ")", ";", "SDNode", "*", "Hi1", "=", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "MVT", "::", "i32", ",", "RHS", ",", "Sub1", ")", ";", "SDVTList", "VTList", "=", "CurDAG", "->", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Glue", ")", ";", "unsigned", "Opc", "=", "IsAdd", "?", "AMDGPU", "::", "S_ADD_U32", ":", "AMDGPU", "::", "S_SUB_U32", ";" ]

[ "]", ";" ]

[ "extern", "_", "_", "inline", "int", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_extract_epi64", "(", "_", "_", "m128i", "_", "_", "X", ",", "const", "int", "_", "_", "N", ")", "{", "return", "(", "(", "_", "_", "v2di", ")", "_", "_", "X", ")", "[", "_", "_", "N", "&", "<NUM_LIT>" ]

[ "SDValue", "StoreHigh", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "dl", ",", "High", ",", "HighAddr", ",", "ST", "->", "getSrcValue", "(", ")", ",", "SVOffset", "+", "<NUM_LIT>", ",", "MVT", "::", "i16", ",", "ST", "->", "isVolatile", "(", ")", ",", "ST", "->", "isNonTemporal", "(", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "unsigned", "ABIAlignment", "=", "getTargetData", "(", ")", "->", "getABITypeAlignment", "(", "ST", "->", "getMemoryVT", "(", ")", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ")", ";", "if", "(", "ST", "->", "getAlignment", "(", ")", ">=", "ABIAlignment", ")", "{", "return", "SDValue", "(", ")", ";", "}", "SDValue", "Chain", "=", "ST", "->", "getChain", "(", ")", ";", "SDValue", "BasePtr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "SDValue", "Value", "=", "ST", "->", "getValue", "(", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "if", "(", "ST", "->", "getAlignment", "(", ")", "==", "<NUM_LIT>", ")", "{", "int", "SVOffset", "=", "ST", "->", "getSrcValueOffset", "(", ")", ";", "SDValue", "Low", "=", "Value", ";", "SDValue", "High", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i32", ",", "Value", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "StoreLow", "=", "DAG", ".", "getTruncStore", "(", "Chain", ",", "dl", ",", "Low", ",", "BasePtr", ",", "ST", "->", "getSrcValue", "(", ")", ",", "SVOffset", ",", "MVT", "::", "i16", ",", "ST", "->", "isVolatile", "(", ")", ",", "ST", "->", "isNonTemporal", "(", ")", ",", "<NUM_LIT>", ")", ";", "SDValue", "HighAddr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "return", "Mask", ";" ]

[ "int", "LaneElts", "=", "<NUM_LIT>", "/", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "NumLanes", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "i", "<", "NumLanes", ";", "++", "i", ")", "for", "(", "int", "j", "=", "<NUM_LIT>", ";", "j", "<", "LaneElts", ";", "++", "j", ")", "assert", "(", "Mask", "[", "j", "]", "==", "Mask", "[", "i", "*", "LaneElts", "+", "j", "]", "-", "(", "LaneElts", "*", "i", ")", "&&", "<STR_LIT>", "Mask doesn't repeat in high 128-bit lanes!", "<STR_LIT>", ")", ";", "Mask", ".", "resize", "(", "LaneElts", ")", ";", "}", "switch", "(", "N", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "}" ]

[ "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "const", "MCExpr", "*", "EVal", ";", "switch", "(", "getLexer", "(", ")", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "case", "AsmToken", "::", "Plus", ":", "case", "AsmToken", "::", "Minus", ":", "case", "AsmToken", "::", "Integer", ":", "if", "(", "getParser", "(", ")", ".", "ParseExpression", "(", "EVal", ")", ")", "return", "<NUM_LIT>", ";", "int64_t", "ans", ";", "EVal", "->", "EvaluateAsAbsolute", "(", "ans", ")", ";", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "EVal", ",", "S", ",", "E", ")", ";", "}" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "[", "(", "V64QI", "<STR_LIT>", ")", "(", "V32HI", "<STR_LIT>", ")", "(", "V16SI", "<STR_LIT>", ")", "(", "V8DI", "<STR_LIT>", ")", "(", "V32QI", "<STR_LIT>", ")", "(", "V16HI", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V16QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V16SF", "<STR_LIT>", ")", "(", "V8DF", "<STR_LIT>", ")", "(", "V8SF", "<STR_LIT>", ")", "(", "V4DF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "(", "define_mode_attr", "ssehalfvecmode", "<BUGS>", "[", "(", "V32QI", "<STR_LIT>", ")", "(", "V16HI", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V16QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V8SF", "<STR_LIT>", ")", "(", "V4DF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_mode_attr", "ssePSmode" ]

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

[ "int", "NegFrameSize", "=", "-", "FrameSize", ";", "bool", "IsLargeFrame", "=", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "NegFrameSize", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Align", "MaxAlign", "=", "MFI", ".", "getMaxAlign", "(", ")", ";", "bool", "HasRedZone", "=", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", "." ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "P", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "W", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "dir", ".", "load", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "opc", ";" ]

[ "}" ]

[ "static", "bool", "isMMAType", "(", "Type", "*", "Ty", ")", "{", "return", "Ty", "->", "isVectorTy", "(", ")", "&&", "(", "Ty", "->", "getScalarSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "&&", "(", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ">", "<NUM_LIT>", ")", ";" ]

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

[ "if", "(", "ISD", "::", "isUnsignedIntSetCC", "(", "CC", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "N00VT", "=", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "EVT", "MatchingVecType", "=", "N00VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "if", "(", "Size", "!=", "MatchingVecType", ".", "getSizeInBits", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "VT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CC", ")", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", ")", "Res", "=", "DAG", ".", "getZeroExtendInReg", "(", "Res", ",", "dl", ",", "N0", ".", "getValueType" ]

[ "if", "(", "&", "MI", "!=", "&", "*", "SecondTerm", ")", "return", "false", ";" ]

[ "if", "(", "HII", "->", "analyzeBranch", "(", "B", ",", "TBB", ",", "FBB", ",", "Cond", ",", "false", ")", ")", "{", "if", "(", "HII", "->", "isNewValueJump", "(", "*", "FirstTerm", ")", ")", "TBB", "=", "FirstTerm", "->", "getOperand", "(", "HII", "->", "getCExtOpNum", "(", "*", "FirstTerm", ")", ")", ".", "getMBB", "(", ")", ";", "}", "if", "(", "TBB", "&&", "&", "MI", "==", "&", "*", "FirstTerm", ")", "{", "Distance", "=", "std", "::", "abs", "(", "(", "long", "long", ")", "InstOffset", "-", "BlockToInstOffset", "[", "TBB", "]", ")", "+", "BranchRelaxSafetyBuffer", ";", "return", "!", "HII", "->", "isJumpWithinBranchRange", "(", "*", "FirstTerm", ",", "Distance", ")", ";", "}", "if", "(", "FBB", ")", "{", "auto", "SecondTerm", "=", "std", "::", "next", "(", "FirstTerm", ")", ";", "assert", "(", "SecondTerm", "!=", "B", ".", "instr_end", "(", ")", "&&", "(", "SecondTerm", "->", "isBranch", "(", ")", "||", "SecondTerm", "->", "isCall", "(", ")", ")", "&&", "<STR_LIT>", "Bad second terminator", "<STR_LIT>", ")", ";" ]

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

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

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

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_psllqi128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "_", "_", "B", ",", "(", "_", "_", "v2di", ")", "_", "mm_setzero_si128", "(", ")" ]

[ "}" ]

[ "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "-- immediate operand is ", "<STR_LIT>", "<<", "MO", ".", "getImm", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", " -- operand is an expression\\n", "<STR_LIT>", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MI", ",", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";" ]

[ ")" ]

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

[ ")", "{" ]

[ "inline", "static", "unsigned", "HIX22", "(", "int64_t", "imm" ]

[ "}" ]

[ "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "PreserveAll", ":", "return", "Is24Bit", "?", "CC_EZ80_C", ":", "CC_Z80_C", ";", "case", "CallingConv", "::", "Z80_LibCall", ":", "return", "CC_EZ80_LC_AB", ";", "case", "CallingConv", "::", "Z80_LibCall_AC", ":", "return", "CC_EZ80_LC_AC", ";", "case", "CallingConv", "::", "Z80_LibCall_BC", ":", "return", "CC_EZ80_LC_BC", ";", "case", "CallingConv", "::", "Z80_LibCall_C", ":", "return", "CC_EZ80_LC_C", ";", "case", "CallingConv", "::", "Z80_LibCall_L", ":", "return", "CC_EZ80_LC_L", ";", "}" ]

[ ")", ";" ]

[ "SDValue", "SystemZTargetLowering", "::", "lowerRETURNADDR", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "setReturnAddressIsTaken", "(", "true", ")", ";", "if", "(", "verifyReturnAddressArgumentIsConstant", "(", "Op", ",", "DAG", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "unsigned", "Depth", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "EVT", "PtrVT", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")" ]

[ "if", "(", "i", "==", "<NUM_LIT>", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "LoadUnitVecVT", ",", "ScalarLoad", ")", ";" ]

[ "EVT", "HalfEltVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "RegVT", ".", "getScalarSizeInBits", "(", ")", "/", "<NUM_LIT>", ")", ";", "EVT", "HalfVecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "HalfEltVT", ",", "NumElems", ")", ";", "Load", "=", "DAG", ".", "getExtLoad", "(", "Ext", ",", "dl", ",", "HalfVecVT", ",", "Ld", "->", "getChain", "(", ")", ",", "Ld", "->", "getBasePtr", "(", ")", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "MemVT", ",", "Ld", "->", "isVolatile", "(", ")", ",", "Ld", "->", "isNonTemporal", "(", ")", ",", "Ld", "->", "isInvariant", "(", ")", ",", "Ld", "->", "getAlignment", "(", ")", ")", ";", "}", "assert", "(", "Load", "->", "getNumValues", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Loads must carry a chain!", "<STR_LIT>", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "Ld", ",", "<NUM_LIT>", ")", ",", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getSExtOrTrunc", "(", "Load", ",", "dl", ",", "RegVT", ")", ";", "}", "assert", "(", "isPowerOf2_32", "(", "RegSz", "*", "MemSz", "*", "NumElems", ")", "&&", "<STR_LIT>", "Non-power-of-two elements are not custom lowered!", "<STR_LIT>", ")", ";", "MVT", "SclrLoadTy", "=", "MVT", "::", "i8", ";", "for", "(", "MVT", "Tp", ":", "MVT", "::", "integer_valuetypes", "(", ")", ")", "{", "if", "(", "TLI", ".", "isTypeLegal", "(", "Tp", ")", "&&", "(", "(", "MemSz", "%", "Tp", ".", "getSizeInBits", "(", ")", ")", "==", "<NUM_LIT>", ")", ")", "{", "SclrLoadTy", "=", "Tp", ";", "}", "}", "if", "(", "TLI", ".", "isTypeLegal", "(", "MVT", "::", "f64", ")", "&&", "SclrLoadTy", ".", "getSizeInBits", "(", ")", "<", "<NUM_LIT>", "&&", "(", "<NUM_LIT>", "<=", "MemSz", ")", ")", "SclrLoadTy", "=", "MVT", "::", "f64", ";", "unsigned", "NumLoads", "=", "MemSz", "/", "SclrLoadTy", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "(", "Ext", "!=", "ISD", "::", "SEXTLOAD", "||", "NumLoads", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Can only lower sext loads with a single scalar load!", "<STR_LIT>", ")", ";", "unsigned", "loadRegZize", "=", "RegSz", ";", "if", "(", "Ext", "==", "ISD", "::", "SEXTLOAD", "&&", "RegSz", ">=", "<NUM_LIT>", ")", "loadRegZize", "=", "<NUM_LIT>", ";", "EVT", "LoadUnitVecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "SclrLoadTy", ",", "loadRegZize", "/", "SclrLoadTy", ".", "getSizeInBits", "(", ")", ")", ";", "EVT", "WideVecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MemVT", ".", "getScalarType", "(", ")", ",", "loadRegZize", "/", "MemVT", ".", "getScalarSizeInBits", "(", ")", ")", ";", "assert", "(", "WideVecVT", ".", "getSizeInBits", "(", ")", "==", "LoadUnitVecVT", ".", "getSizeInBits", "(", ")", "&&", "<STR_LIT>", "Invalid vector type", "<STR_LIT>", ")", ";", "assert", "(", "TLI", ".", "isTypeLegal", "(", "WideVecVT", ")", "&&", "<STR_LIT>", "We only lower types that form legal widened vector types", "<STR_LIT>", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Chains", ";", "SDValue", "Ptr", "=", "Ld", "->", "getBasePtr", "(", ")", ";", "SDValue", "Increment", "=", "DAG", ".", "getConstant", "(", "SclrLoadTy", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ",", "dl", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getUNDEF", "(", "LoadUnitVecVT", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumLoads", ";", "++", "i", ")", "{", "SDValue", "ScalarLoad", "=", "DAG", ".", "getLoad", "(", "SclrLoadTy", ",", "dl", ",", "Ld", "->", "getChain", "(", ")", ",", "Ptr", ",", "Ld", "->", "getPointerInfo", "(", ")", ",", "Ld", "->", "isVolatile", "(", ")", ",", "Ld", "->", "isNonTemporal", "(", ")", ",", "Ld", "->", "isInvariant", "(", ")", ",", "Ld", "->", "getAlignment", "(", ")", ")", ";", "Chains", ".", "push_back", "(", "ScalarLoad", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

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

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

[ ";" ]

[ "bool", "MOSLateOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "Changed", "|=", "lowerCMPTermZs", "(", "MBB", ")", ";", "Changed", "|=", "ldImmToInxyDexy", "(", "MBB", ")", ";", "}", "return", "Changed" ]

[ "case", "Intrinsic", "::", "mips_msubu", ":" ]

[ "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_dpax_w_ph", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_dpsx_w_ph", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_mulsa_w_ph", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_mult", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_multu", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_madd", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_maddu", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";", "case", "Intrinsic", "::", "mips_msub", ":", "return", "lowerDSPIntr", "(", "Op", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ";" ]

[ "{" ]

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

[ "(", "<STR_LIT>", "missing predicate operand", "<STR_LIT>", ")", ";" ]

[ "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "if", "(", "Pred", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "llvm_unreachable", "(", "<STR_LIT>", "lesser than 2 predicate operands are provided", "<STR_LIT>", ")", ";", "int", "i", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "i", "==", "-", "<NUM_LIT>", ")", "llvm_unreachable" ]

[ "$", "dst", ")", ">", ";" ]

[ "def", "DCBTT", ":", "PPCAsmPseudo", "<", "<STR_LIT>", ",", "(", "ins", "memrr", ":" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ ")", ")" ]

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

[ "bool", "SystemZAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "<STR_LIT>", "Unknown missing feature!", "<STR_LIT>", ")", ";", "std", "::", "string", "Msg", "=", "<STR_LIT>", "instruction requires:", "<STR_LIT>", ";", "uint64_t", "Mask", "=", "<NUM_LIT>", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "sizeof", "(", "ErrorInfo", ")", "*", "<NUM_LIT>", "-", "<NUM_LIT>", ";", "++", "I", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "<STR_LIT>", "<STR_LIT>", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "<NUM_LIT>", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "(", "(", "SystemZOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction", "<STR_LIT>", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected match type", "<STR_LIT>", ")", ";", "}" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

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

[ "OperandMatchResultTy", "P2AsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "reg_no", ",", "SMLoc", "&", "start", ",", "SMLoc", "&", "end", ")", "{", "start", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "reg_no", "=", "parseRegister", "(", "<STR_LIT>", "<STR_LIT>", ")", ";", "end", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "if", "(", "reg_no", "==", "(", "unsigned", ")", "-", "<NUM_LIT>", ")", "return", "MatchOperand_NoMatch", ";", "return", "MatchOperand_Success", ";", "}" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_sub_ps", "(", "_", "_", "m512", "_", "_", "W", ",", "_", "_", "mmask16", "_", "_", "U", ",", "_", "_", "m512", "_", "_", "A", ",", "_", "_", "m512", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_subps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "_", "B", ",", "(", "_", "_", "v16sf", ")", "_", "_", "W", ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

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

[ "bool", "NoFloat", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "{", "unsigned", "MaxIntSize", "=", "Subtarget", ".", "is64Bit", "(" ]

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

[ "def", "SMC", ":", "ExceptionGeneration", "<", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "}" ]

[ "def", "A6_vminub_RdP", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ",", "PredRegs", ":", "$", "Pe4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rtt32", ",", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_f9058dd7", ",", "TypeM", ">", ",", "Enc_d2c7f1", ",", "Requires", "<", "[", "HasV62", "]", ">", "{", "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", "prefersSlot3", "=", "<NUM_LIT>", ";" ]

[ ">", ";" ]

[ "def", "v16i8", ":", "ROTQBIIVecInst", "<", "v16i8", ",", "u7imm_i32", ",", "i32", ",", "uimm7" ]

[ ".", "Chain", ";" ]

[ "SDValue", "Cpu0TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "CLI" ]

[ "_", "_", "Y", ",", "_", "_", "O", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_insertf128_ps", "(", "_", "_", "m256", "_", "_", "X", ",", "_", "_", "m128", "_", "_", "Y", ",", "const", "int", "_", "_", "O", ")", "{", "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_vinsertf128_ps256", "(", "(", "_", "_", "v8sf", ")", "_", "_", "X", ",", "(", "_", "_", "v4sf", ")" ]

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

[ "[", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_REGISTER_USE", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", ")" ]

[ "}" ]

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

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

[ "return", "(", "int16x4_t", ")" ]