C++ CompoundConstantEmitter::addEntry方法代码示例

/// populateInstInfo - Fills an array of InstInfos with information about each
///   instruction in a target
///
/// @arg infoArray  - The array of InstInfo objects to populate
/// @arg target     - The CodeGenTarget to use as a source of instructions
static void populateInstInfo(CompoundConstantEmitter &infoArray,
                             CodeGenTarget &target) {
    std::vector<const CodeGenInstruction*> numberedInstructions;
    target.getInstructionsByEnumValue(numberedInstructions);

    unsigned int index;
    unsigned int numInstructions = numberedInstructions.size();

    for (index = 0; index < numInstructions; ++index) {
        const CodeGenInstruction& inst = *numberedInstructions[index];

        CompoundConstantEmitter *infoStruct = new CompoundConstantEmitter;
        infoArray.addEntry(infoStruct);

        FlagsConstantEmitter *instFlags = new FlagsConstantEmitter;
        infoStruct->addEntry(instFlags);

        LiteralConstantEmitter *numOperandsEmitter =
            new LiteralConstantEmitter(inst.OperandList.size());
        infoStruct->addEntry(numOperandsEmitter);

        CompoundConstantEmitter *operandFlagArray = new CompoundConstantEmitter;
        infoStruct->addEntry(operandFlagArray);

        FlagsConstantEmitter *operandFlags[MAX_OPERANDS];

        for (unsigned operandIndex = 0; operandIndex < MAX_OPERANDS; ++operandIndex) {
            operandFlags[operandIndex] = new FlagsConstantEmitter;
            operandFlagArray->addEntry(operandFlags[operandIndex]);
        }

        unsigned numSyntaxes = 0;

        if (target.getName() == "X86") {
            X86PopulateOperands(operandFlags, inst);
            X86ExtractSemantics(*instFlags, operandFlags, inst);
            numSyntaxes = 2;
        }

        CompoundConstantEmitter *operandOrderArray = new CompoundConstantEmitter;
        infoStruct->addEntry(operandOrderArray);

        for (unsigned syntaxIndex = 0; syntaxIndex < MAX_SYNTAXES; ++syntaxIndex) {
            CompoundConstantEmitter *operandOrder = new CompoundConstantEmitter;
            operandOrderArray->addEntry(operandOrder);

            if (syntaxIndex < numSyntaxes) {
                populateOperandOrder(operandOrder, inst, syntaxIndex);
            }
            else {
                for (unsigned operandIndex = 0;
                        operandIndex < MAX_OPERANDS;
                        ++operandIndex) {
                    operandOrder->addEntry(new LiteralConstantEmitter("-1"));
                }
            }
        }
    }
}

/// populateInstInfo - Fills an array of InstInfos with information about each
///   instruction in a target
///
/// \param infoArray The array of InstInfo objects to populate
/// \param target    The CodeGenTarget to use as a source of instructions
static void populateInstInfo(CompoundConstantEmitter &infoArray,
                             CodeGenTarget &target) {
  const std::vector<const CodeGenInstruction*> &numberedInstructions =
    target.getInstructionsByEnumValue();

  unsigned int index;
  unsigned int numInstructions = numberedInstructions.size();

  for (index = 0; index < numInstructions; ++index) {
    const CodeGenInstruction& inst = *numberedInstructions[index];

    CompoundConstantEmitter *infoStruct = new CompoundConstantEmitter;
    infoArray.addEntry(infoStruct);

    LiteralConstantEmitter *instType = new LiteralConstantEmitter;
    infoStruct->addEntry(instType);

    LiteralConstantEmitter *numOperandsEmitter =
      new LiteralConstantEmitter(inst.Operands.size());
    infoStruct->addEntry(numOperandsEmitter);

    CompoundConstantEmitter *operandTypeArray = new CompoundConstantEmitter;
    infoStruct->addEntry(operandTypeArray);

    LiteralConstantEmitter *operandTypes[EDIS_MAX_OPERANDS];

    CompoundConstantEmitter *operandFlagArray = new CompoundConstantEmitter;
    infoStruct->addEntry(operandFlagArray);

    FlagsConstantEmitter *operandFlags[EDIS_MAX_OPERANDS];

    for (unsigned operandIndex = 0;
         operandIndex < EDIS_MAX_OPERANDS;
         ++operandIndex) {
      operandTypes[operandIndex] = new LiteralConstantEmitter;
      operandTypeArray->addEntry(operandTypes[operandIndex]);

      operandFlags[operandIndex] = new FlagsConstantEmitter;
      operandFlagArray->addEntry(operandFlags[operandIndex]);
    }

    unsigned numSyntaxes = 0;

    // We don't need to do anything for pseudo-instructions, as we'll never
    // see them here. We'll only see real instructions.
    // We still need to emit null initializers for everything.
    if (!inst.isPseudo) {
      if (target.getName() == "X86") {
        X86PopulateOperands(operandTypes, inst);
        X86ExtractSemantics(*instType, operandFlags, inst);
        numSyntaxes = 2;
      }
      else if (target.getName() == "ARM") {
        ARMPopulateOperands(operandTypes, inst);
        ARMExtractSemantics(*instType, operandTypes, operandFlags, inst);
        numSyntaxes = 1;
      }
    }

    CompoundConstantEmitter *operandOrderArray = new CompoundConstantEmitter;

    infoStruct->addEntry(operandOrderArray);

    for (unsigned syntaxIndex = 0;
         syntaxIndex < EDIS_MAX_SYNTAXES;
         ++syntaxIndex) {
      CompoundConstantEmitter *operandOrder =
        new CompoundConstantEmitter(EDIS_MAX_OPERANDS);

      operandOrderArray->addEntry(operandOrder);

      if (syntaxIndex < numSyntaxes) {
        populateOperandOrder(operandOrder, inst, syntaxIndex);
      }
    }

    infoStruct = NULL;
  }
}