Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "frv_nops", "[", "frv_num_nops", "++", "]", "=", "nop_insn", ";" ]

[ "SET_NEXT_INSN", "(", "nop_insn", ")", "=", "<NUM_LIT>", ";", "SET_PREV_INSN", "(", "nop_insn", ")", "=", "<NUM_LIT>", ";" ]

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

[ "if", "(", "IsValidLdStrOpc", ")", "*", "IsValidLdStrOpc", "=", "true", ";", "switch", "(", "Opc", ")", "{", "default", ":", "if", "(", "IsValidLdStrOpc", ")", "*", "IsValidLdStrOpc", "=", "false", ";", "return", "UINT_MAX", ";", "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>", ":", "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>", ":", "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>", ":", "return", "Opc", ";" ]

[ "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "ISD", "::", "SETLT", ")", ";" ]

[ "SDValue", "GprIndexPlusOne", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "GprIndex", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "GprIndex", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "dl", ",", "MVT", "::", "i32", ",", "CC64", ",", "GprIndexPlusOne", ",", "GprIndex", ")", ";", "}", "SDValue", "FprPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "FprIndex", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "ZEXTLOAD", ",", "dl", ",", "MVT", "::", "i32", ",", "InChain", ",", "FprPtr", ",", "MachinePointerInfo", "(", "SV", ")", ",", "MVT", "::", "i8", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "FprIndex", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "RegSaveAreaPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OverflowAreaPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "VAListPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "OverflowArea", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "InChain", ",", "OverflowAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "OverflowArea", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "RegSaveArea", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "InChain", ",", "RegSaveAreaPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "InChain", "=", "RegSaveArea", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "CC", "=", "DAG", ".", "getSetCC", "(", "dl", ",", "MVT", "::", "i32", ",", "VT", ".", "isInteger", "(", ")", "?", "GprIndex", ":", "FprIndex", ",", "DAG", ".", "getConstant" ]

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

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

[ "}" ]

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

[ "<NUM_LIT>", ";" ]

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

[ "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "FIdx", ",", "NULL", ",", "<NUM_LIT>", ")", ";" ]

[ "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FrameIdx", "=", "FrameInfo", "->", "CreateStackObject", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "MVT", "PtrVT", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "getPointerTy", "(", ")", ";", "SDValue", "FIdx", "=", "DAG", ".", "getFrameIndex", "(", "FrameIdx", ",", "PtrVT", ")", ";" ]

[ "<FIXS>", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "if", "(", "NumVals", "!=", "<NUM_LIT>", ")", "{", "if", "(", "Subtarget", "->", "isGP64bit", "(", ")", "&&", "NumVals", "==", "<NUM_LIT>", "&&", "MO", ".", "isReg", "(", ")", ")", "{", "<BUGS>", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "<BUGE>", "O", "<<", "'", "$", "'", "<<", "MipsInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}" ]

[ "}" ]

[ "if", "(", "Amount", "!=", "<NUM_LIT>", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "-", "<NUM_LIT>", "U", ")", "{", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "CalleePopAmount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";" ]

[ ")" ]

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

[ "static", "int", "ix86_mode_needed", "(", "int", "entity", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_needed", "(", "insn", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "return", "ix86_i387_mode_needed", "(", "entity", ",", "insn", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

[ "-", "B", ")", ";" ]

[ "StringRef", "::", "const_iterator", "I", ",", "B", "=", "C", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "E", "=", "C", ".", "end", "(", ")", "-", "<NUM_LIT>", ";", "I", "=", "std", "::", "find_if", "(", "B", ",", "E", ",", "isdigit", ")", ";", "Prefix", ".", "assign", "(", "B", ",", "I" ]

[ "unsigned", "CAHPInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "<NUM_LIT>", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "CAHPTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

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

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

[ "else", "{" ]

[ "if", "(", "isCopy", "(", "SU", ")", ")", "assert", "(", "false", "&&", "<STR_LIT>", "cannot handle COPY", "<STR_LIT>", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "const", "TargetInstrDesc", "desc", "=", "MI", "->", "getDesc", "(", ")", ";", "int", "udx", "=", "-", "<NUM_LIT>", ",", "xuse", "=", "<NUM_LIT>", ";", "if", "(", "isFlexibleInstruction", "(", "desc", ")", ")", "{", "static", "int", "unit_prio", "[", "]", "=", "{", "unit_l", ",", "unit_s", ",", "unit_m", ",", "unit_d", "}", ";", "unsigned", "support", "=", "desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "int", "unit", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "array_lengthof", "(", "unit_prio", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unit", "=", "unit_prio", "[", "i", "]", ";", "if", "(", "(", "support", ">>", "unit", ")", "&", "<NUM_LIT>", ")", "{", "MachineOperand", "&", "unitOp", "=", "MI", "->", "getOperand", "(", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "unitOp", ".", "setImm", "(", "unit", "<<", "<NUM_LIT>", ")", ";", "DEBUG", "(", "DBGSCHED", "(", "dbgs", "(", ")", ",", "MI", ")", "<<", "<STR_LIT>", "scheduled on unit .", "<STR_LIT>", "<<", "TMS320C64XInstrInfo", "::", "getUnitStrings", "(", ")", "[", "unit", "]", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "udx", "=", "getUnitIndex", "(", "side", ",", "unit", ")", ";", "break", ";", "}", "}", "if", "(", "desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "xuse", "=", "(", "side", "==", "<NUM_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "std", "::", "set", "<", "const", "TargetRegisterClass", "*", ">", "RCs", "=", "getOperandRCs", "(", "MI", ")", ";", "if", "(", "RCs", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "xuse", "=", "(", "side", "==", "<NUM_LIT>", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "DEBUG", "(", "DBGSCHED", "(", "dbgs", "(", ")", ",", "MI", ")", "<<", "<STR_LIT>", "xuse: ", "<STR_LIT>", "<<", "(", "xuse", "?", "getExtraStr", "(", "xuse", ")", ":", "<STR_LIT>", "none", "<STR_LIT>", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}" ]

[ "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";" ]

[ "std", "::", "pair", "<", "int", ",", "int", ">", "<STR_LIT>", "::", "<STR_LIT>", "(", "const", "MachineInstr", "*", "MI", ",", "MachineRegisterInfo", "&", "MRI", ")", "{", "int", "opcntA", "=", "<NUM_LIT>", ",", "opcntB", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "std", "::", "min", "(", "MI", "->", "getNumOperands", "(", ")", ",", "(", "unsigned", ")", "MI", "->", "getDesc", "(", ")", ".", "NumOperands", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "TargetOperandInfo", "&", "TOI", "=", "MI", "->", "getDesc", "(", ")", ".", "OpInfo", "[", "i", "]", ";", "if", "(", "TOI", ".", "isPredicate", "(", ")", ")", "continue", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";" ]

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

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

[ "<FIXS>", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "STriw", ")", ")", ".", "<FIXE>" ]

[ "}", "else", "{", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "TFR_RsPd", ")", ",", "HEXAGON_RESERVED_REG_2", ")", ".", "addReg", "(", "SrcReg", ")", ";", "<BUGS>", "BuildMI", "(", "*", "MBB", ",", "MII", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Hexagon", "::", "STriw_indexed", ")", ")", ".", "<BUGE>", "addReg", "(", "FP", ")", ".", "addImm", "(", "Offset", ")", ".", "addReg", "(", "HEXAGON_RESERVED_REG_2", ")", ";", "}", "MII", "=", "MBB", "->", "erase", "(", "MI", ")", ";" ]

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

[ "def", "_H", ":", "sve_int_perm_insrv", "<", "<NUM_LIT>", ",", "asm", ",", "ZPR16" ]

[ ",", "list", "<", "dag", ">", "pattern", ">", ":", "I", "<", "opcode", ",", "OOL", ",", "IOL", ",", "asmstr", ",", "itin", ">", "{" ]

[ "class", "XFLForm_1", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "xo", ",", "dag", "OOL", ",", "dag", "IOL", ",", "string", "asmstr", ",", "InstrItinClass", "itin" ]

[ "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "OpReg", ",", "getKillRegState", "(", "OpIsKill", ")", ")", ";" ]

[ "Register", "OpReg", "=", "getRegForValue", "(", "Opnd", ")", ";", "if", "(", "OpReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "bool", "OpIsKill", "=", "hasTrivialKill", "(", "Opnd", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "RetVT", ")", ";", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";" ]

[ ")", "==", "<STR_LIT>", "mipsallegrexel-", "<STR_LIT>", ")", "return", "<NUM_LIT>", ";" ]

[ "unsigned", "MipselTargetMachine", "::", "getModuleMatchQuality", "(", "const", "Module", "&", "M", ")", "{", "std", "::", "string", "TT", "=", "M", ".", "getTargetTriple", "(", ")", ";", "if", "(", "TT", ".", "size", "(", ")", ">=", "<NUM_LIT>", "&&", "std", "::", "string", "(", "TT", ".", "begin", "(", ")", ",", "TT", ".", "begin", "(", ")", "+", "<NUM_LIT>", ")", "==", "<STR_LIT>", "mipsel-", "<STR_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "TT", ".", "size", "(", ")", ">=", "<NUM_LIT>", "&&", "std", "::", "string", "(", "TT", ".", "begin", "(", ")", ",", "TT", ".", "begin", "(", ")", "+", "<NUM_LIT>" ]

[ "<FIXS>", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "AArch64Subtarget", ">", "(", ")", ";", "unsigned", "UnspilledCSGPR", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "UnspilledCSGPRPaired", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "<FIXE>" ]

[ "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "static_cast", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "AArch64FunctionInfo", ">", "(", ")", ";", "<BUGS>", "SmallVector", "unsigned", ",", "<NUM_LIT>", ">", "UnspilledCSGPRs", ";", "SmallVector", "unsigned", ",", "<NUM_LIT>", ">", "UnspilledCSFPRs", ";", "<BUGE>", "if", "(", "hasFP", "(", "MF", ")", ")", "{" ]

[ "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "*", "T", ",", "createPPCMCInstrInfo", ")", ";" ]

[ "void", "LLVMInitializePowerPCTargetMC", "(", ")", "{", "for", "(", "Target", "*", "T", ":", "{", "&", "ThePPC32Target", ",", "&", "ThePPC64Target", ",", "&", "ThePPC64LETarget", "}", ")", "{", "RegisterMCAsmInfoFn", "C", "(", "*", "T", ",", "createPPCMCAsmInfo", ")", ";", "TargetRegistry", "::", "registerMCAdjustCodeGenOpts", "(", "*", "T", ",", "adjustCodeGenOpts", ")", ";" ]

[ "(", "f32", "(", "IMPLICIT_DEF", ")", ")", ",", "GR32", ":", "$", "src", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "f32", "(", "sint_to_fp", "GR32", ":", "$", "src", ")", ")", ",", "(", "VCVTSI2SSrr" ]

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

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

[ "ARM", "::", "R0", ")", ")", ";" ]

[ "void", "ARMInstrInfo", "::", "getNoop", "(", "MCInst", "&", "NopInst", ")", "const", "{", "if", "(", "hasNOP", "(", ")", ")", "{", "NopInst", ".", "setOpcode", "(", "ARM", "::", "HINT", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "NopInst", ".", "setOpcode", "(", "ARM", "::", "MOVr", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "ARM", "::", "R0", ")", ")", ";", "NopInst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(" ]

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

[ "if", "(", "!", "Extension", ".", "Features", ")", "report_fatal_error", "(", "<STR_LIT>", "unsupported architectural extension: ", "<STR_LIT>", "+", "Name", ")", ";", "if", "(", "(", "getAvailableFeatures", "(", ")", "&", "Extension", ".", "ArchCheck", ")", "!=", "Extension", ".", "ArchCheck", ")", "{", "Error", "(", "ExtLoc", ",", "<STR_LIT>", "architectural extension '", "<STR_LIT>", "+", "Name", "+", "<STR_LIT>", "' is not ", "<STR_LIT>", "<STR_LIT>", "allowed for the current base architecture", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "uint64_t", "ToggleFeatures", "=", "EnableFeature", "?", "(", "~", "STI", ".", "getFeatureBits", "(", ")", "&", "Extension", ".", "Features", ")", ":", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "Extension", ".", "Features", ")", ";", "uint64_t", "Features", "=", "ComputeAvailableFeatures", "(", "STI", ".", "ToggleFeature", "(", "ToggleFeatures", ")", ")", ";", "setAvailableFeatures", "(", "Features", ")", ";", "return", "false", ";", "}", "Error", "(", "ExtLoc", ",", "<STR_LIT>", "unknown architectural extension: ", "<STR_LIT>", "+", "Name", ")", ";", "Parser", ".", "eatToEndOfStatement" ]

[ "static", "int", "sched_get_indexed_address_scale", "(", "rtx_insn", "*", "pro", ",", "rtx_insn", "*", "con", ")", "{", "rtx", "reg", ";", "rtx", "mem", ";", "struct", "m68k_address", "address", ";", "reg", "=", "sched_get_reg_operand", "(", "pro", ",", "true", ")", ";", "if", "(", "reg", "==", "NULL", ")", "return", "<NUM_LIT>", ";", "mem", "=", "sched_get_mem_operand", "(", "con", ",", "true", ",", "false", ")", ";", "gcc_assert", "(", "mem", "!=", "NULL", "&&", "MEM_P", "(", "mem", ")", ")", ";", "if", "(", "!", "m68k_decompose_address", "(", "GET_MODE", "(", "mem", ")", ",", "XEXP", "(", "mem", ",", "<NUM_LIT>", ")", ",", "reload_completed", ",", "&", "address", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "address", ".", "index", ")", ")", "{", "gcc_assert", "(", "address", ".", "scale", "!=", "<NUM_LIT>", ")", ";", "return", "address", ".", "scale", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Helper", "function", "for", "m68k_sched_indexed_address_bypass_p", ".", "if", "PRO", "modifies", "register", "used", "as", "index", "in", "CON", ",", "return", "scale", "of", "indexed", "memory", "access", "in", "CON", ".", "Return", "zero", "overwise", "." ]

[ ")", ";" ]

[ "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassForNode", "(", "DAG", ",", "Op" ]

[ ")", ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const_string", "<STR_LIT>" ]

[ "<STR_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", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=" ]

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

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

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

[ "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_loadapd512_mask", "(", "(", "const", "_", "_", "v8df", "*", ")", "_", "_", "P", ",", "(", "_" ]

[ "ARM_ABI_UNKNOWN", ")", ";" ]

[ "bool", "ARMSubtarget", "::", "isAAPCS16_ABI", "(", ")", "const", "{", "assert", "(", "TM", ".", "TargetABI", "!=", "ARMBaseTargetMachine", "::" ]

[ "<FIXS>", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "<FIXE>" ]

[ "void", "PadShortFunc", "::", "addPadding", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "int", "NOOPsToAdd", ")", "{", "<BUGS>", "const", "DebugLoc", "&", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "<BUGE>", "unsigned", "IssueWidth", "=", "TSM", ".", "getIssueWidth", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "IssueWidth", "*", "NOOPsToAdd", ";", "i", "!=", "e", ";", "++", "i", ")" ]

[ "const", "TargetRegisterClass", "*", ">", "(", ")", ";" ]

[ "if", "(", "const", "RegisterBank", "*", "RB", "=", "RCOrRB", ".", "dyn_cast", "<", "const", "RegisterBank", "*", ">", "(", ")", ")", "return", "getRegClassForTypeOnBank", "(", "MRI", ".", "getType", "(", "MO", ".", "getReg", "(", ")", ")", ",", "*", "RB", ",", "MRI", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RCOrRB", ".", "get", "<" ]

[ ":", "PARM_BOUNDARY", ";" ]

[ "if", "(", "res", "<", "<NUM_LIT>", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "<STR_LIT>", "parameter passing for argument of type %qT ", "<STR_LIT>", "<STR_LIT>", "changed in GCC 7.1", "<STR_LIT>", ",", "type", ")", ";", "if", "(", "res", ">", "<NUM_LIT>", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "<STR_LIT>", "parameter passing for argument of type ", "<STR_LIT>", "<STR_LIT>", "%qT changed in GCC 9.1", "<STR_LIT>", ",", "type", ")", ";", "return", "res", ">", "<NUM_LIT>", "?", "DOUBLEWORD_ALIGNMENT" ]

[ ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{" ]

[ "SmallString", "<", "<NUM_LIT>", ">", "bundleString", ";", "raw_svector_ostream", "OS", "(", "bundleString", ")", ";", "unsigned", "bundleSize", "=", "<NUM_LIT>", ";", "bool", "nopBundle", "=", "false", ";", "MIiter", "I", "=", "mir", ".", "first", ";", "for", "(", ";", "I", "!=", "mir", ".", "second", ";", "++", "I", ")", "{", "const", "MachineInstr", "*", "MI", "=", "I", ";", "const", "char", "*", "prefix", "=", "<STR_LIT>", "\\t", "<STR_LIT>", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "nopBundle", "=", "true", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MIiter", "next", "=", "llvm", "::", "next", "(", "I", ")", ";", "if", "(", "nopBundle", "&&", "next", "!=", "mir", ".", "second", "&&", "next", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "continue", ";", "else", "break", ";", "}", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(" ]

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

[ "(", "vec_select", ":", "V8HI", "(", "match_dup", "<NUM_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>", ")", "]", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_select", ":", "V8HI", "(", "match_dup", "<NUM_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>", ")", "]", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "vec_select", ":", "V8HI" ]

[ "_", "_", "v16hi", ")", "_", "_", "B", ",", "<NUM_LIT>", ",", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_ucmpw256_mask", "(", "(", "_", "_", "v16hi", ")", "_", "_", "A", ",", "(" ]

[ "true", ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "DMB", ")", "{", "if", "(", "IsRemovableNextDMB", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "DMBType", ")", "{", "ToRemove", ".", "push_back", "(", "&", "MI", ")", ";", "}", "else", "{", "DMBType", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "{", "IsRemovableNextDMB", "=", "true", ";", "DMBType", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "}", "}", "else", "if", "(", "!", "CanMovePastDMB", "(", "&", "MI", ")", ")", "{", "IsRemovableNextDMB", "=", "false", ";", "}", "}", "}", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "MI", ":", "ToRemove", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "++", "NumDMBsRemoved", ";", "Changed", "=" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ ")", ";" ]

[ "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Can't load this register from stack slot", "<STR_LIT>" ]

[ "}" ]

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

[ "}" ]

[ "F", "=", "new", "MCBoundaryAlignFragment", "(", "AlignBoundary", ")", ";", "OS", ".", "insert", "(", "F", ")", ";", "}", "return", "F", ";" ]

[ "C", ",", "_", "_", "D", ",", "(", "_", "_", "v4si", ")", "_", "mm_avx512_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "A", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpshld_v4si_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "B", ",", "(", "_", "_", "v4si", ")", "_", "_" ]

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

[ "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "return", "mips_output_move", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "{" ]

[ "EVT", "AMDGPUTargetLowering", "::", "genIntType", "(", "uint32_t", "size", ",", "uint32_t", "numEle", ")", "const", "{", "int", "iSize", "=", "(", "size", "*", "numEle", ")", ";", "int", "vEle", "=", "(", "iSize", ">>", "(", "(", "size", "==", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "vEle", ")", "{", "vEle", "=", "<NUM_LIT>", ";", "}", "if", "(", "size", "==", "<NUM_LIT>", ")", "{", "if", "(", "vEle", "==", "<NUM_LIT>", ")", "{", "return", "EVT", "(", "MVT", "::", "i64", ")", ";", "}", "else" ]

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

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

[ ")" ]

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

[ "<FIXS>", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v1i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v2i64", ",", "Custom", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v4i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v4i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v8i16", ",", "Custom", ")", ";", "<BUGS>", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v1i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";", "<BUGE>", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "v1i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "MVT", "::", "v2i64", ",", "Expand", ")", ";" ]

[ ";" ]

[ "def", "rr", ":", "AsI1", "<", "opcod", ",", "(", "outs", "GPR", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "GPR", ":", "$", "Rm", ")", ",", "DPFrm", ",", "iir", ",", "opc", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteALU", ",", "ReadALU", ",", "ReadALU", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm" ]

[ "<FIXS>", "rtx", "operands", "ATTRIBUTE_UNUSED", ";", "<FIXE>" ]

[ "voidthumb_reload_out_si", "(", "operands", ")", "<BUGS>", "rtx", "operands", ";", "<BUGE>", "{", "abort", "(", ")", ";", "}" ]

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

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmaxuq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")" ]

[ ")", ")" ]

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

[ "<FIXS>", "def", "IRET", ":", "PseudoI", "(", "outs", ")", ",", "(", "ins", "i32imm", ":", "$", "adj", ")", ",", "[", "(", "X86iret", "timm", ":", "$", "adj", ")", "]", ">", ";", "def", "RET", ":", "PseudoI", "(", "outs", ")", ",", "(", "ins", "i32imm", ":", "$", "adj", ",", "variable_ops", ")", ",", "[", "(", "X86retflag", "timm", ":", "$", "adj", ")", "]", ">", ";", "<FIXE>" ]

[ "def", "IRET64", ":", "RI", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIC_IRET", ">", ",", "Requires", "[", "In64BitMode", "]", ">", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "IRET", ":", "PseudoI", "(", "outs", ")", ",", "(", "ins", "i16imm", ":", "$", "adj", ")", ",", "[", "(", "X86iret", "timm", ":", "$", "adj", ")", "]", ">", ";", "<BUGE>", "}" ]

[ "<FIXS>", "int", "count", "ATTRIBUTE_UNUSED", ";", "<FIXE>" ]

[ "rtxreturn_addr_rtx", "(", "count", ",", "frameaddr", ")", "<BUGS>", "int", "count", ";", "<BUGE>", "rtx", "frameaddr", ";", "{", "rtx", "label", ";" ]

[ "InstrItinClass", "Itinerary", "=", "itin", ";" ]

[ "dag", "InOperandList", "=", "(", "ins", "ROS", ":", "$", "rs", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "set", "ROWD", ":", "$", "wd", ",", "(", "VT", "(", "OpNode", "ROS", ":", "$", "rs", ")", ")", ")", "]", ";" ]

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

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

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM CGP: Mutation complete\\n", "<STR_LIT>", ")", ";" ]

[ "else", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "I", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "TruncTysMap", "[", "I", "]", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", ")", "->", "getType", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "*", "V", ":", "Visited", ")", "{", "if", "(", "!", "isa", "<", "TruncInst", ">", "(", "V", ")", "||", "Sources", ".", "count", "(", "V", ")", ")", "continue", ";", "auto", "*", "Trunc", "=", "cast", "<", "TruncInst", ">", "(", "V", ")", ";", "TruncTysMap", "[", "Trunc", "]", ".", "push_back", "(", "Trunc", "->", "getDestTy", "(", ")", ")", ";", "}", "PrepareConstants", "(", ")", ";", "ExtendSources", "(", ")", ";", "PromoteTree", "(", ")", ";", "ConvertTruncs", "(", ")", ";", "TruncateSinks", "(", ")", ";", "Cleanup", "(", ")", ";" ]

[ ")", ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "match_code", "<STR_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>", ";" ]

[ ",", "mem", ")", ";" ]

[ "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "reg", ")", "==", "REG", ")", ";", "dest", "=", "ia64_single_set", "(", "consumer", ")", ";", "gcc_assert", "(", "dest", ")", ";", "mem", "=", "SET_DEST", "(", "dest", ")", ";", "gcc_assert", "(", "mem", "&&", "GET_CODE", "(", "mem", ")", "==", "MEM", ")", ";", "return", "reg_mentioned_p", "(", "reg" ]

[ "}" ]

[ "if", "(", "!", "Inst", ")", "continue", ";", "if", "(", "auto", "*", "BI", "=", "dyn_cast", "<", "BitCastInst", ">", "(", "Inst", ")", ")", "{", "traceBitCast", "(", "BI", ",", "Parent", ",", "Kind", ")", ";", "}", "else", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "Inst", ")", ")", "{", "uint32_t", "CIKind", ";", "if", "(", "IsPreserveDIAccessIndexCall", "(", "CI", ",", "CIKind", ")", ")", "{", "AIChain", "[", "CI", "]", "=", "std", "::", "make_pair", "(", "Parent", ",", "Kind", ")", ";", "traceAICall", "(", "CI", ",", "CIKind", ")", ";", "}", "else", "{", "BaseAICalls", "[", "Parent", "]", "=", "Kind", ";", "}", "}", "else", "if", "(", "auto", "*", "GI", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "Inst", ")", ")", "{", "if", "(", "GI", "->", "hasAllZeroIndices", "(", ")", ")", "traceGEP", "(", "GI", ",", "Parent", ",", "Kind", ")", ";", "else", "BaseAICalls", "[", "Parent", "]", "=", "Kind", ";", "}", "}" ]

[ "}" ]

[ "class", "LoadInst_MovFlavorT", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "DAGOperand", "Src", ",", "string", "asmstr", ",", "Operand", "Pred", ">", ":", "LoadInst_MovFlavor", "<", "opc", ",", "Rdst", ",", "Src", ",", "asmstr", ",", "Pred", ">", "{", "let", "InOperandList", "=", "(", "ins", "Src", ":", "$", "src", ",", "i32imm", ":", "$", "flavor", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "isAsmParserOnly", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "[", "(", "set", "(", "reg", ":", "DI", "GSR_REG", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "reg", ":", "DI", "GSR_REG", ")", "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_WRGSR", ")", ")", "]", "<BUGE>", "<STR_LIT>", "{", "if", "(", "!", "TARGET_ARCH64", ")" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "convertCharsToWord", "(", "Str", ",", "i", ")", ")", ")", ";" ]

[ "const", "size_t", "PaddedLen", "=", "getPaddedLen", "(", "Str", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "PaddedLen", ";", "i", "+=", "<NUM_LIT>", ")", "{" ]

[ "<FIXS>", "def", "CORE_SHIFT", ":", "ALU_RR", "BPF_ALU64", ",", "BPF_LSH", ",", "<NUM_LIT>", ",", "<FIXE>" ]

[ "<STR_LIT>", ",", "[", "]", ">", ";", "let", "Constraints", "=", "<STR_LIT>", "in", "{", "<BUGS>", "def", "CORE_SHIFT", ":", "ALU_RR", "BPF_ALU64", ",", "BPF_LSH", ",", "<BUGE>", "(", "outs", "GPR", ":", "$", "dst", ")", ",", "(", "ins", "u64imm", ":", "$", "opcode", ",", "GPR", ":", "$", "src", ",", "u64imm", ":", "$", "offset", ")", ",", "<STR_LIT>", "," ]

[ "getAddNoCarry", "(", "MBB", ",", "MI", ",", "DL", ",", "TmpReg", ")", ".", "addImm", "(", "LDSOffset", ")", ".", "addReg", "(", "TIDReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "!", "Entry", ".", "isLiveIn", "(", "Reg", ")", ")", "Entry", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "RS", "->", "enterBasicBlock", "(", "Entry", ")", ";", "unsigned", "STmp0", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "<NUM_LIT>", ")", ";", "unsigned", "STmp1", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_LOAD_DWORD_IMM", ")", ",", "STmp0", ")", ".", "addReg", "(", "InputPtrReg", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "::", "NGROUPS_Z", ")", ";", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_LOAD_DWORD_IMM", ")", ",", "STmp1", ")", ".", "addReg", "(", "InputPtrReg", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "::", "NGROUPS_Y", ")", ";", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_MUL_I32", ")", ",", "STmp1", ")", ".", "addReg", "(", "STmp1", ")", ".", "addReg", "(", "STmp0", ")", ";", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MUL_U32_U24_e32", ")", ",", "TIDReg", ")", ".", "addReg", "(", "STmp1", ")", ".", "addReg", "(", "TIDIGXReg", ")", ";", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MAD_U32_U24", ")", ",", "TIDReg", ")", ".", "addReg", "(", "STmp0", ")", ".", "addReg", "(", "TIDIGYReg", ")", ".", "addReg", "(", "TIDReg", ")", ";", "getAddNoCarry", "(", "Entry", ",", "Insert", ",", "DL", ",", "TIDReg", ")", ".", "addReg", "(", "TIDReg", ")", ".", "addReg", "(", "TIDIGZReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MBCNT_LO_U32_B32_e64", ")", ",", "TIDReg", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MBCNT_HI_U32_B32_e64", ")", ",", "TIDReg", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ".", "addReg", "(", "TIDReg", ")", ";", "}", "BuildMI", "(", "Entry", ",", "Insert", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_LSHLREV_B32_e32", ")", ",", "TIDReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "TIDReg", ")", ";", "MFI", "->", "setTIDReg", "(", "TIDReg", ")", ";", "}", "unsigned", "LDSOffset", "=", "MFI", "->", "getLDSSize", "(", ")", "+", "(", "FrameOffset", "*", "WorkGroupSize", ")", ";" ]

[ "!=", "E", ";" ]

[ "static", "bool", "hasNonInstructionUse", "(", "GlobalVariable", "*", "GV", ")", "{", "for", "(", "Value", "::", "use_iterator", "UI", "=", "GV", "->", "use_begin", "(", ")", ",", "E", "=", "GV", "->", "use_end", "(", ")", ";", "UI" ]

[ ")" ]

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

[ "<FIXS>", "MBlazeSubtarget", "::", "MBlazeSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "<FIXE>", "<FIXS>", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "<STR_LIT>", "mblaze", "<STR_LIT>", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPUName", ")", ";", "<FIXE>", "<FIXS>", "HasItin", "=", "CPUName", "!=", "<STR_LIT>", "mblaze", "<STR_LIT>", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "CPU ", "<STR_LIT>", "<<", "CPUName", "<<", "<STR_LIT>", "(", "<STR_LIT>", "<<", "HasItin", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "llvm/Support/CommandLine.h", "<STR_LIT>", "using", "namespace", "llvm", ";", "<BUGS>", "MBlazeSubtarget", "::", "MBlazeSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "<BUGE>", "HasBarrel", "(", "false", ")", ",", "HasDiv", "(", "false", ")", ",", "HasMul", "(", "false", ")", ",", "HasPatCmp", "(", "false", ")", ",", "HasFPU", "(", "false", ")", ",", "HasMul64", "(", "false", ")", ",", "HasSqrt", "(", "false", ")", "{", "<BUGS>", "std", "::", "string", "CPU", "=", "<STR_LIT>", "mblaze", "<STR_LIT>", ";", "CPU", "=", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "<BUGE>", "<BUGS>", "HasItin", "=", "CPU", "!=", "<STR_LIT>", "mblaze", "<STR_LIT>", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "CPU ", "<STR_LIT>", "<<", "CPU", "<<", "<STR_LIT>", "(", "<STR_LIT>", "<<", "HasItin", "<<", "<STR_LIT>", ")\\n", "<STR_LIT>", ")", ";", "<BUGE>", "computeIssueWidth", "(", ")", ";" ]

[ "return", "EXIT_SUCCESS", ";" ]

[ "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "<STR_LIT>", "@item %s\\n%s\\n", "<STR_LIT>", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "<STR_LIT>", "@end table\\n", "<STR_LIT>", ")", ";" ]

[ "return", "MCDisassembler", "::", "Success", ";" ]

[ "unsigned", "Reg", "=", "getReg", "(", "Decoder", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "RegNo", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Reg", ")", ")", ";" ]

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

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "!", "matchWrapper", "(", "N", ",", "AM", ")", ")", "return", "false", ";", "break", ";", "case", "ISD", "::", "ADD", ":", "{", "HandleSDNode", "Handle", "(", "N", ")", ";", "X86ISelAddressMode", "Backup", "=", "AM", ";", "if", "(", "!", "matchVectorAddressRecursively", "(", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ",", "Depth", "+", "<NUM_LIT>", ")", "&&", "!", "matchVectorAddressRecursively", "(", "Handle", ".", "getValue", "(", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ",", "Depth", "+", "<NUM_LIT>", ")", ")", "return", "false", ";", "AM", "=", "Backup", ";", "if", "(", "!", "matchVectorAddressRecursively", "(", "Handle", ".", "getValue", "(", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ",", "Depth", "+", "<NUM_LIT>", ")", "&&", "!", "matchVectorAddressRecursively", "(", "Handle", ".", "getValue", "(", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "AM", ",", "Depth", "+", "<NUM_LIT>", ")", ")", "return", "false", ";", "AM", "=", "Backup", ";", "N", "=", "Handle", ".", "getValue" ]

[ "return", "ix86_prepare_fp_compare_args", "(", "code", ",", "pop0", ",", "pop1", ")", ";" ]

[ "if", "(", "op_mode", "==", "BFmode", ")", "{", "rtx", "op", "=", "gen_lowpart", "(", "HImode", ",", "op0", ")", ";", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "op", "=", "simplify_const_unary_operation", "(", "FLOAT_EXTEND", ",", "SFmode", ",", "op0", ",", "BFmode", ")", ";", "else", "{", "rtx", "t1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_zero_extendhisi2", "(", "t1", ",", "op", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "t1", ",", "t1", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "op", "=", "gen_lowpart", "(", "SFmode", ",", "t1", ")", ";", "}", "*", "pop0", "=", "op", ";", "op", "=", "gen_lowpart", "(", "HImode", ",", "op1", ")", ";", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "op", "=", "simplify_const_unary_operation", "(", "FLOAT_EXTEND", ",", "SFmode", ",", "op1", ",", "BFmode", ")", ";", "else", "{", "rtx", "t1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_zero_extendhisi2", "(", "t1", ",", "op", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "t1", ",", "t1", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "op", "=", "gen_lowpart", "(", "SFmode", ",", "t1", ")", ";", "}", "*", "pop1", "=", "op", ";" ]

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

[ "<STR_LIT>", "{", "rtx", "l", "=", "gen_reg_rtx", "(", "V4HImode", ")", "rtx", "h", "=", "gen_reg_rtx", "(", "V4HImode", ")", "emit_insn", "(", "gen_vec_widen_umult_lo_v8qi", "(", "l", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_insn", "(", "gen_vec_widen_umult_hi_v8qi", "(", "h", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "if", "(", "TARGET_BIG_ENDIAN", ")", "emit_insn", "(", "gen_vec_pack_trunc_v4hi", "(", "operands", "[", "<NUM_LIT>", "]", ",", "h" ]

[ "<FIXS>", "if", "(", "AFI", "->", "isInterruptHandler", "(", ")", "&&", "CallConv", "!=", "CallingConv", "::", "AVR_SIGNAL", ")", "{", "<FIXE>" ]

[ "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "<BUGS>", "if", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", ")", "{", "<BUGE>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";" ]

[ ")", ";" ]

[ "AtomicSDNode", "*", "AtomicNode", "=", "cast", "<", "AtomicSDNode", ">", "(", "Op", ")", ";", "assert", "(", "AtomicNode", "->", "isCompareAndSwap", "(", ")", ")", ";", "unsigned", "AS", "=", "AtomicNode", "->", "getAddressSpace", "(", ")", ";", "if", "(", "!", "isFlatGlobalAddrSpace", "(", "AS", ")", ")", "return", "Op", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "ChainIn", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Addr", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Old", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "New", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "MVT", "SimpleVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "MVT", "VecType", "=", "MVT", "::", "getVectorVT", "(", "SimpleVT", ",", "<NUM_LIT>", ")", ";", "SDValue", "NewOld", "=", "DAG", ".", "getBuildVector", "(", "VecType", ",", "DL", ",", "{", "New", ",", "Old", "}", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "ChainIn", ",", "Addr", ",", "NewOld", "}", ";", "SDVTList", "VTList", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "Other" ]

[ ">", ";" ]

[ "class", "CLASS_D_ENC", ":", "COP1_2R_FM", "<", "<NUM_LIT>", ",", "FIELD_FMT_D" ]

[ "mask", "|", "=", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")", "<", "<", "<NUM_LIT>" ]

[ "int", "mask", "mask", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "mask", "|", "=", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")", "<", "<", "<NUM_LIT>", "mask", "|", "=", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")", "<", "<", "<NUM_LIT>", "mask", "|", "=", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")", "<", "<", "<NUM_LIT>", "mask", "|", "=", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ")", "<", "<", "<NUM_LIT>" ]

[ "}", "=", "pattern", ";" ]

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

[ "static", "void", "lm32_block_move_inline", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ",", "HOST_WIDE_INT", "alignment", ")", "{", "HOST_WIDE_INT", "offset", ",", "delta", ";", "unsigned", "HOST_WIDE_INT", "bits", ";", "int", "i", ";", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "switch", "(", "alignment", ")", "{", "case", "<NUM_LIT>", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "bits", "=", "<NUM_LIT>", ";", "break", ";", "}", "mode", "=", "mode_for_size", "(", "bits", ",", "MODE_INT", ",", "<NUM_LIT>", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "XALLOCAVEC", "(", "rtx", ",", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "<NUM_LIT>", ",", "i", "=", "<NUM_LIT>", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "regs", "[", "i", "]", ",", "adjust_address", "(", "src", ",", "mode", ",", "offset", ")", ")", ";", "}", "for", "(", "offset", "=", "<NUM_LIT>", ",", "i", "=", "<NUM_LIT>", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "emit_move_insn", "(", "adjust_address", "(", "dest", ",", "mode", ",", "offset", ")", ",", "regs", "[", "i", "]", ")", ";", "if", "(", "offset", "<", "length", ")", "{", "src", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "move_by_pieces", "(", "dest", ",", "src", ",", "length", "-", "offset", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ",", "<NUM_LIT>", ")", ";", "}", "}" ]

[ "Emit", "straight-line", "code", "to", "move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "areas", "do", "not", "overlap", "." ]

[ "<FIXS>", "if", "(", "args_so_farp", "->", "regs", "+", "<NUM_LIT>", "MMIX_MAX_ARGS_IN_REGS", ")", "*", "pretend_sizep", "=", "(", "MMIX_MAX_ARGS_IN_REGS", "-", "(", "args_so_farp", "->", "regs", "+", "<NUM_LIT>", ")", ")", "*", "<NUM_LIT>", ";", "<FIXE>" ]

[ "int", "*", "pretend_sizep", ";", "int", "second_time", "ATTRIBUTE_UNUSED", ";", "{", "<BUGS>", "if", "(", "current_function_stdarg", ")", "{", "if", "(", "args_so_farp", "->", "regs", "+", "<NUM_LIT>", "MMIX_MAX_ARGS_IN_REGS", ")", "*", "pretend_sizep", "=", "(", "MMIX_MAX_ARGS_IN_REGS", "-", "(", "args_so_farp", "->", "regs", "+", "<NUM_LIT>", ")", ")", "*", "<NUM_LIT>", ";", "}", "else", "if", "(", "current_function_varargs", ")", "{", "if", "(", "args_so_farp", "->", "regs", "MMIX_MAX_ARGS_IN_REGS", ")", "*", "pretend_sizep", "=", "(", "MMIX_MAX_ARGS_IN_REGS", "-", "args_so_farp", "->", "regs", ")", "*", "<NUM_LIT>", ";", "args_so_farp", "->", "now_varargs", "=", "<NUM_LIT>", ";", "}", "elseinternal_error", "(", "<STR_LIT>", "neither varargs or stdarg in mmix_setup_incoming_varargs", "<STR_LIT>", ")", ";", "<BUGE>" ]

[ "<STR_LIT>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "<", "V_cmp_mixed", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "<", "V_cmp_mixed", ">", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "VDQF_COND", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VDQF_COND", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", "(", "match_operand", ":", "<", "V_cmp_mixed", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "<", "V_cmp_mixed", ">", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";" ]

[ "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "RetOps", "(", "<NUM_LIT>", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Can't return value from vararg function in memory", "<STR_LIT>", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "i8imm", ":", "$", "movdgall", ")", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MovDGAllAsmOperand", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "SDValue", "LanaiTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unimplemented operand", "<STR_LIT>", ")", ";", "}", "}" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

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

[ "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_vfmaddsubpd128_mask3", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "(", "_", "_", "v2df", ")", "_", "_", "B", "," ]

[ "static", "void", "sparc_emit_set_const32", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "temp", "=", "op0", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "temp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "{", "gcc_assert", "(", "!", "small_int_operand", "(", "op1", ",", "mode", ")", "&&", "!", "const_high_operand", "(", "op1", ",", "mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "GEN_INT", "(", "INTVAL", "(", "op1", ")", "&", "~", "(", "HOST_WIDE_INT", ")", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_IOR", "(", "mode", ",", "temp", ",", "GEN_INT", "(", "INTVAL", "(", "op1", ")", "&", "<NUM_LIT>", ")", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "gen_rtx_HIGH", "(", "mode", ",", "op1", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_LO_SUM", "(", "mode", ",", "temp", ",", "op1", ")", ")", ")", ";", "}", "}" ]

[ "We", "know", "it", "ca", "n't", "be", "done", "in", "one", "insn", "when", "we", "get", "here", ",", "the", "movsi", "expander", "guarentees", "this", "." ]

[ "<FIXS>", "cpp_define", "(", "pfile", ",", "avr_toupper", "(", "Name", ",", "name", ")", ")", ";", "<FIXE>" ]

[ "const", "char", "*", "name", "=", "avr_addrspace", "[", "i", "]", ".", "name", ";", "char", "*", "Name", "=", "(", "char", "*", ")", "alloca", "(", "<NUM_LIT>", "+", "strlen", "(", "name", ")", ")", ";", "<BUGS>", "cpp_define_formatted", "(", "pfile", ",", "<STR_LIT>", "%s=%s", "<STR_LIT>", ",", "avr_toupper", "(", "Name", ",", "name", ")", ",", "name", ")", ";", "<BUGE>", "}", "}" ]

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

[ "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "<NUM_LIT>", ";", "}", "bool", "hasUnsigned", "=", "Subtarget", "->", "hasSSE41", "(", ")", "||", "(", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "VT", "==", "MVT", "::", "v16i8", ")", ";", "bool", "hasSigned", "=", "Subtarget", "->", "hasSSE41", "(", ")", "||", "(", "Subtarget", "->", "hasSSE2", "(", ")", "&&", "VT", "==", "MVT", "::", "v8i16", ")", ";", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "if", "(", "DAG", ".", "isEqualTo", "(", "LHS", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "DAG", ".", "isEqualTo", "(", "RHS", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETULE", ":", "return", "hasUnsigned", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETUGE", ":", "return", "hasUnsigned", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "case", "ISD", "::", "SETLT", ":", "case", "ISD", "::", "SETLE", ":", "return", "hasSigned", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "case", "ISD", "::", "SETGT", ":", "case", "ISD", "::", "SETGE", ":", "return", "hasSigned", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "DAG", ".", "isEqualTo", "(", "LHS", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "DAG", ".", "isEqualTo", "(", "RHS", ",", "Cond", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETULE", ":", "return", "hasUnsigned", "?", "<STR_LIT>", "::" ]

[ "char_type_node", ")", ";" ]

[ "static", "tree", "c6x_build_builtin_va_list", "(", "void", ")", "{", "return", "build_pointer_type", "(" ]

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

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

[ "}" ]

[ "const", "MCOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "O", "<<", "A64CondCodeToString", "(", "static_cast", "<", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "MO", ".", "getImm", "(", ")", ")", ")", ";" ]

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

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Do not know how to custom type legalize this operation!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "RTB", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "RTB", ",", "RTB", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ")", ";", "Results", ".", "push_back", "(", "RTB", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", "!=", "Intrinsic", "::", "loop_decrement", ")", "break", ";", "assert", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i1", "&&", "<STR_LIT>", "Unexpected result type for CTR decrement intrinsic", "<STR_LIT>", ")", ";", "EVT", "SVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "SVT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "NewInt", "=", "DAG", ".", "getNode", "(", "N", "->", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i1", ",", "NewInt", ")", ")", ";", "Results", ".", "push_back", "(", "NewInt", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "VAARG", ":", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "Subtarget", ".", "isPPC64" ]

[ "}" ]

[ "static", "_", "_", "inline__", "float", "_", "_", "fnabsf", "(", "float", "x", ")", "{", "float", "r", ";", "_", "_", "asm__", "(", "<STR_LIT>", "fnabs %0,%1", "<STR_LIT>", ":", "<STR_LIT>", "=f", "<STR_LIT>", "(", "r", ")", ":", "<STR_LIT>", "f", "<STR_LIT>", "(", "x", ")", ")", ";", "return", "r", ";" ]