Commit eff08f40 authored by Reid Kleckner's avatar Reid Kleckner
Browse files

Revert "[Sema][X86] Consider target attribute into the checks in... 

Revert "[Sema][X86] Consider target attribute into the checks in validateOutputSize and validateInputSize."

This reverts commit e1578fd2.

It introduces a dependency on Attr.h which I am removing from
ASTContext.h.
parent b22d8ae7

clang/include/clang/AST/ASTContext.h

+0 −11
Original line number Diff line number Diff line
@@ -95,7 +95,6 @@ class CXXRecordDecl; 
class DiagnosticsEngine;

class Expr;

class FixedPointSemantics;

class GlobalDecl;

class MangleContext;

class MangleNumberingContext;

class MaterializeTemporaryExpr;
@@ -2821,16 +2820,6 @@ public: 
  /// PredefinedExpr to cache evaluated results.

  StringLiteral *getPredefinedStringLiteralFromCache(StringRef Key) const;



  /// Parses the target attributes passed in, and returns only the ones that are

  /// valid feature names.

  TargetAttr::ParsedTargetAttr

  filterFunctionTargetAttrs(const TargetAttr *TD) const;



  void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,

                             const FunctionDecl *) const;

  void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,

                             GlobalDecl GD) const;



  //===--------------------------------------------------------------------===//

  //                    Statistics

  //===--------------------------------------------------------------------===//

clang/include/clang/Basic/TargetInfo.h

+2 −4
Original line number Diff line number Diff line
@@ -945,14 +945,12 @@ public: 
  bool validateInputConstraint(MutableArrayRef<ConstraintInfo> OutputConstraints,

                               ConstraintInfo &info) const;



  virtual bool validateOutputSize(const llvm::StringMap<bool> &FeatureMap,

                                  StringRef /*Constraint*/,

  virtual bool validateOutputSize(StringRef /*Constraint*/,

                                  unsigned /*Size*/) const {

    return true;

  }



  virtual bool validateInputSize(const llvm::StringMap<bool> &FeatureMap,

                                 StringRef /*Constraint*/,

  virtual bool validateInputSize(StringRef /*Constraint*/,

                                 unsigned /*Size*/) const {

    return true;

  }

clang/lib/AST/ASTContext.cpp

+0 −63
Original line number Diff line number Diff line
@@ -10779,66 +10779,3 @@ QualType ASTContext::getCorrespondingSignedFixedPointType(QualType Ty) const { 
    llvm_unreachable("Unexpected unsigned fixed point type");

  }

}
 


TargetAttr::ParsedTargetAttr

ASTContext::filterFunctionTargetAttrs(const TargetAttr *TD) const {

  assert(TD != nullptr);

  TargetAttr::ParsedTargetAttr ParsedAttr = TD->parse();



  ParsedAttr.Features.erase(

      llvm::remove_if(ParsedAttr.Features,

                      [&](const std::string &Feat) {

                        return !Target->isValidFeatureName(

                            StringRef{Feat}.substr(1));

                      }),

      ParsedAttr.Features.end());

  return ParsedAttr;

}



void ASTContext::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,

                                       const FunctionDecl *FD) const {

  if (FD)

    getFunctionFeatureMap(FeatureMap, GlobalDecl().getWithDecl(FD));

  else

    Target->initFeatureMap(FeatureMap, getDiagnostics(),

                           Target->getTargetOpts().CPU,

                           Target->getTargetOpts().Features);

}



// Fills in the supplied string map with the set of target features for the

// passed in function.

void ASTContext::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,

                                       GlobalDecl GD) const {

  StringRef TargetCPU = Target->getTargetOpts().CPU;

  const FunctionDecl *FD = GD.getDecl()->getAsFunction();

  if (const auto *TD = FD->getAttr<TargetAttr>()) {

    TargetAttr::ParsedTargetAttr ParsedAttr = filterFunctionTargetAttrs(TD);



    // Make a copy of the features as passed on the command line into the

    // beginning of the additional features from the function to override.

    ParsedAttr.Features.insert(

        ParsedAttr.Features.begin(),

        Target->getTargetOpts().FeaturesAsWritten.begin(),

        Target->getTargetOpts().FeaturesAsWritten.end());



    if (ParsedAttr.Architecture != "" &&

        Target->isValidCPUName(ParsedAttr.Architecture))

      TargetCPU = ParsedAttr.Architecture;



    // Now populate the feature map, first with the TargetCPU which is either

    // the default or a new one from the target attribute string. Then we'll use

    // the passed in features (FeaturesAsWritten) along with the new ones from

    // the attribute.

    Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU,

                           ParsedAttr.Features);

  } else if (const auto *SD = FD->getAttr<CPUSpecificAttr>()) {

    llvm::SmallVector<StringRef, 32> FeaturesTmp;

    Target->getCPUSpecificCPUDispatchFeatures(

        SD->getCPUName(GD.getMultiVersionIndex())->getName(), FeaturesTmp);

    std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());

    Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU, Features);

  } else {

    Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU,

                           Target->getTargetOpts().Features);

  }

}

clang/lib/Basic/Targets/X86.cpp

+8 −11
Original line number Diff line number Diff line
@@ -1731,24 +1731,21 @@ bool X86TargetInfo::validateAsmConstraint( 
  }

}



bool X86TargetInfo::validateOutputSize(const llvm::StringMap<bool> &FeatureMap,

                                       StringRef Constraint,

bool X86TargetInfo::validateOutputSize(StringRef Constraint,

                                       unsigned Size) const {

  // Strip off constraint modifiers.

  while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')

    Constraint = Constraint.substr(1);



  return validateOperandSize(FeatureMap, Constraint, Size);

  return validateOperandSize(Constraint, Size);

}



bool X86TargetInfo::validateInputSize(const llvm::StringMap<bool> &FeatureMap,

                                      StringRef Constraint,

bool X86TargetInfo::validateInputSize(StringRef Constraint,

                                      unsigned Size) const {

  return validateOperandSize(FeatureMap, Constraint, Size);

  return validateOperandSize(Constraint, Size);

}



bool X86TargetInfo::validateOperandSize(const llvm::StringMap<bool> &FeatureMap,

                                        StringRef Constraint,

bool X86TargetInfo::validateOperandSize(StringRef Constraint,

                                        unsigned Size) const {

  switch (Constraint[0]) {

  default:
@@ -1773,7 +1770,7 @@ bool X86TargetInfo::validateOperandSize(const llvm::StringMap<bool> &FeatureMap, 
    case 'z':

    case '0':

      // XMM0

      if (FeatureMap.lookup("sse"))

      if (SSELevel >= SSE1)

        return Size <= 128U;

      return false;

    case 'i':
@@ -1787,10 +1784,10 @@ bool X86TargetInfo::validateOperandSize(const llvm::StringMap<bool> &FeatureMap, 
    LLVM_FALLTHROUGH;

  case 'v':

  case 'x':

    if (FeatureMap.lookup("avx512f"))

    if (SSELevel >= AVX512F)

      // 512-bit zmm registers can be used if target supports AVX512F.

      return Size <= 512U;

    else if (FeatureMap.lookup("avx"))

    else if (SSELevel >= AVX)

      // 256-bit ymm registers can be used if target supports AVX.

      return Size <= 256U;

    return Size <= 128U;

clang/lib/Basic/Targets/X86.h

+6 −9
Original line number Diff line number Diff line
@@ -177,11 +177,9 @@ public: 
    return false;

  }



  bool validateOutputSize(const llvm::StringMap<bool> &FeatureMap,

                          StringRef Constraint, unsigned Size) const override;

  bool validateOutputSize(StringRef Constraint, unsigned Size) const override;



  bool validateInputSize(const llvm::StringMap<bool> &FeatureMap,

                         StringRef Constraint, unsigned Size) const override;

  bool validateInputSize(StringRef Constraint, unsigned Size) const override;



  virtual bool

  checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const override {
@@ -193,8 +191,8 @@ public: 
    return true;

  };



  virtual bool validateOperandSize(const llvm::StringMap<bool> &FeatureMap,

                                   StringRef Constraint, unsigned Size) const;



  virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;



  std::string convertConstraint(const char *&Constraint) const override;

  const char *getClobbers() const override {
@@ -370,8 +368,7 @@ public: 
    return -1;

  }



  bool validateOperandSize(const llvm::StringMap<bool> &FeatureMap,

                           StringRef Constraint, unsigned Size) const override {

  bool validateOperandSize(StringRef Constraint, unsigned Size) const override {

    switch (Constraint[0]) {

    default:

      break;
@@ -389,7 +386,7 @@ public: 
      return Size <= 64;

    }



    return X86TargetInfo::validateOperandSize(FeatureMap, Constraint, Size);

    return X86TargetInfo::validateOperandSize(Constraint, Size);

  }



  void setMaxAtomicWidth() override {