diff --git a/CHANGELOG.md b/CHANGELOG.md
index ee2b3eff..0d68bf3c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ It includes many new rules, including all new techniques introduced in MITRE ATT
 - rule: add file-scope feature (`function-name`) for recognized library functions #567 @williballenthin
 - main: auto detect shellcode based on file extension #516 @mr-tz
 - main: more detailed progress bar output when matching functions #562 @mr-tz
+- main: detect file limitations without doing code analysis for better performance #583 @williballenthin
 
 ### New Rules (77)
 
diff --git a/capa/features/extractors/helpers.py b/capa/features/extractors/helpers.py
index 8dc39bea..bcc647a9 100644
--- a/capa/features/extractors/helpers.py
+++ b/capa/features/extractors/helpers.py
@@ -6,12 +6,9 @@
 #  is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and limitations under the License.
 
-import sys
+import struct
 import builtins
 
-from capa.features.file import Import
-from capa.features.insn import API
-
 MIN_STACKSTRING_LEN = 8
 
 
@@ -87,3 +84,49 @@ def twos_complement(val, bits):
     else:
         # return positive value as is
         return val
+
+
+def carve_pe(pbytes, offset=0):
+    """
+    Return a list of (offset, size, xor) tuples of embedded PEs
+
+    Based on the version from vivisect:
+      https://github.com/vivisect/vivisect/blob/7be4037b1cecc4551b397f840405a1fc606f9b53/PE/carve.py#L19
+    And its IDA adaptation:
+      capa/features/extractors/ida/file.py
+    """
+    mz_xor = [
+        (
+            xor_static(b"MZ", i),
+            xor_static(b"PE", i),
+            i,
+        )
+        for i in range(256)
+    ]
+
+    pblen = len(pbytes)
+    todo = [(pbytes.find(mzx, offset), mzx, pex, i) for mzx, pex, i in mz_xor]
+    todo = [(off, mzx, pex, i) for (off, mzx, pex, i) in todo if off != -1]
+
+    while len(todo):
+
+        off, mzx, pex, i = todo.pop()
+
+        # The MZ header has one field we will check
+        # e_lfanew is at 0x3c
+        e_lfanew = off + 0x3C
+        if pblen < (e_lfanew + 4):
+            continue
+
+        newoff = struct.unpack("<I", xor_static(pbytes[e_lfanew : e_lfanew + 4], i))[0]
+
+        nextres = pbytes.find(mzx, off + 1)
+        if nextres != -1:
+            todo.append((nextres, mzx, pex, i))
+
+        peoff = off + newoff
+        if pblen < (peoff + 2):
+            continue
+
+        if pbytes[peoff : peoff + 2] == pex:
+            yield (off, i)
diff --git a/capa/features/extractors/pefile/__init__.py b/capa/features/extractors/pefile/__init__.py
new file mode 100644
index 00000000..def4476f
--- /dev/null
+++ b/capa/features/extractors/pefile/__init__.py
@@ -0,0 +1,174 @@
+# Copyright (C) 2020 FireEye, Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at: [package root]/LICENSE.txt
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+#  is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+import logging
+
+import pefile
+
+import capa.features.extractors
+import capa.features.extractors.helpers
+import capa.features.extractors.strings
+from capa.features import String, Characteristic
+from capa.features.file import Export, Import, Section
+from capa.features.extractors import FeatureExtractor
+
+__all__ = ["file"]
+logger = logging.getLogger(__name__)
+
+
+def extract_file_embedded_pe(pe, file_path):
+    with open(file_path, "rb") as f:
+        fbytes = f.read()
+
+    for offset, i in capa.features.extractors.helpers.carve_pe(fbytes, 1):
+        yield Characteristic("embedded pe"), offset
+
+
+def extract_file_export_names(pe, file_path):
+    base_address = pe.OPTIONAL_HEADER.ImageBase
+
+    if hasattr(pe, "DIRECTORY_ENTRY_EXPORT"):
+        for export in pe.DIRECTORY_ENTRY_EXPORT.symbols:
+            try:
+                name = export.name.partition(b"\x00")[0].decode("ascii")
+            except UnicodeDecodeError:
+                continue
+            va = base_address + export.address
+            yield Export(name), va
+
+
+def extract_file_import_names(pe, file_path):
+    """
+    extract imported function names
+    1. imports by ordinal:
+     - modulename.#ordinal
+    2. imports by name, results in two features to support importname-only matching:
+     - modulename.importname
+     - importname
+    """
+    if hasattr(pe, "DIRECTORY_ENTRY_IMPORT"):
+        for dll in pe.DIRECTORY_ENTRY_IMPORT:
+            try:
+                modname = dll.dll.partition(b"\x00")[0].decode("ascii")
+            except UnicodeDecodeError:
+                continue
+
+            # strip extension
+            modname = modname.rpartition(".")[0].lower()
+
+            for imp in dll.imports:
+                if imp.import_by_ordinal:
+                    impname = "#%s" % imp.ordinal
+                else:
+                    try:
+                        impname = imp.name.partition(b"\x00")[0].decode("ascii")
+                    except UnicodeDecodeError:
+                        continue
+
+                for name in capa.features.extractors.helpers.generate_symbols(modname, impname):
+                    yield Import(name), imp.address
+
+
+def extract_file_section_names(pe, file_path):
+    base_address = pe.OPTIONAL_HEADER.ImageBase
+
+    for section in pe.sections:
+        try:
+            name = section.Name.partition(b"\x00")[0].decode("ascii")
+        except UnicodeDecodeError:
+            continue
+
+        yield Section(name), base_address + section.VirtualAddress
+
+
+def extract_file_strings(pe, file_path):
+    """
+    extract ASCII and UTF-16 LE strings from file
+    """
+    with open(file_path, "rb") as f:
+        b = f.read()
+
+    for s in capa.features.extractors.strings.extract_ascii_strings(b):
+        yield String(s.s), s.offset
+
+    for s in capa.features.extractors.strings.extract_unicode_strings(b):
+        yield String(s.s), s.offset
+
+
+def extract_file_function_names(pe, file_path):
+    """
+    extract the names of statically-linked library functions.
+    """
+    if False:
+        # using a `yield` here to force this to be a generator, not function.
+        yield NotImplementedError("pefile doesn't have library matching")
+    return
+
+
+def extract_file_features(pe, file_path):
+    """
+    extract file features from given workspace
+
+    args:
+      pe (pefile.PE): the parsed PE
+      file_path: path to the input file
+
+    yields:
+      Tuple[Feature, VA]: a feature and its location.
+    """
+
+    for file_handler in FILE_HANDLERS:
+        for feature, va in file_handler(pe, file_path):
+            yield feature, va
+
+
+FILE_HANDLERS = (
+    extract_file_embedded_pe,
+    extract_file_export_names,
+    extract_file_import_names,
+    extract_file_section_names,
+    extract_file_strings,
+    extract_file_function_names,
+)
+
+
+class PefileFeatureExtractor(FeatureExtractor):
+    def __init__(self, path):
+        super(PefileFeatureExtractor, self).__init__()
+        self.path = path
+        self.pe = pefile.PE(path)
+
+    def get_base_address(self):
+        return self.pe.OPTIONAL_HEADER.ImageBase
+
+    def extract_file_features(self):
+        for feature, va in extract_file_features(self.pe, self.path):
+            yield feature, va
+
+    def get_functions(self):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def extract_function_features(self, f):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def get_basic_blocks(self, f):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def extract_basic_block_features(self, f, bb):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def get_instructions(self, f, bb):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def extract_insn_features(self, f, bb, insn):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def is_library_function(self, va):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
+
+    def get_function_name(self, va):
+        raise NotImplementedError("PefileFeatureExtract can only be used to extract file features")
diff --git a/capa/features/extractors/smda/file.py b/capa/features/extractors/smda/file.py
index 7f9ed473..68fee066 100644
--- a/capa/features/extractors/smda/file.py
+++ b/capa/features/extractors/smda/file.py
@@ -9,57 +9,11 @@ from capa.features import String, Characteristic
 from capa.features.file import Export, Import, Section
 
 
-def carve(pbytes, offset=0):
-    """
-    Return a list of (offset, size, xor) tuples of embedded PEs
-
-    Based on the version from vivisect:
-    https://github.com/vivisect/vivisect/blob/7be4037b1cecc4551b397f840405a1fc606f9b53/PE/carve.py#L19
-    And its IDA adaptation:
-    capa/features/extractors/ida/file.py
-    """
-    mz_xor = [
-        (
-            capa.features.extractors.helpers.xor_static(b"MZ", i),
-            capa.features.extractors.helpers.xor_static(b"PE", i),
-            i,
-        )
-        for i in range(256)
-    ]
-
-    pblen = len(pbytes)
-    todo = [(pbytes.find(mzx, offset), mzx, pex, i) for mzx, pex, i in mz_xor]
-    todo = [(off, mzx, pex, i) for (off, mzx, pex, i) in todo if off != -1]
-
-    while len(todo):
-
-        off, mzx, pex, i = todo.pop()
-
-        # The MZ header has one field we will check
-        # e_lfanew is at 0x3c
-        e_lfanew = off + 0x3C
-        if pblen < (e_lfanew + 4):
-            continue
-
-        newoff = struct.unpack("<I", capa.features.extractors.helpers.xor_static(pbytes[e_lfanew : e_lfanew + 4], i))[0]
-
-        nextres = pbytes.find(mzx, off + 1)
-        if nextres != -1:
-            todo.append((nextres, mzx, pex, i))
-
-        peoff = off + newoff
-        if pblen < (peoff + 2):
-            continue
-
-        if pbytes[peoff : peoff + 2] == pex:
-            yield (off, i)
-
-
 def extract_file_embedded_pe(smda_report, file_path):
     with open(file_path, "rb") as f:
         fbytes = f.read()
 
-    for offset, i in carve(fbytes, 1):
+    for offset, i in capa.features.extractors.helpers.carve_pe(fbytes, 1):
         yield Characteristic("embedded pe"), offset
 
 
diff --git a/capa/main.py b/capa/main.py
index 68cec26a..e25a533b 100644
--- a/capa/main.py
+++ b/capa/main.py
@@ -32,6 +32,7 @@ import capa.version
 import capa.features
 import capa.features.freeze
 import capa.features.extractors
+import capa.features.extractors.pefile
 from capa.helpers import get_file_taste
 
 RULES_PATH_DEFAULT_STRING = "(embedded rules)"
@@ -808,6 +809,23 @@ def main(argv=None):
         logger.error("%s", str(e))
         return -1
 
+    if args.format == "pe" or (args.format == "auto" and taste.startswith(b"MZ")):
+        # this pefile file feature extractor is pretty light weight: it doesn't do any code analysis.
+        # so we can fairly quickly determine if the given PE file has "pure" file-scope rules
+        # that indicate a limitation (like "file is packed based on section names")
+        # and avoid doing a full code analysis on difficult/impossible binaries.
+        file_extractor = capa.features.extractors.pefile.PefileFeatureExtractor(args.sample)
+        pure_file_capabilities, _ = find_file_capabilities(rules, file_extractor, {})
+
+        # file limitations that rely on non-file scope won't be detected here.
+        # nor on FunctionName features, because pefile doesn't support this.
+        if has_file_limitation(rules, pure_file_capabilities):
+            # bail if capa encountered file limitation e.g. a packed binary
+            # do show the output in verbose mode, though.
+            if not (args.verbose or args.vverbose or args.json):
+                logger.debug("file limitation short circuit, won't analyze fully.")
+                return -1
+
     if (args.format == "freeze") or (args.format == "auto" and capa.features.freeze.is_freeze(taste)):
         format = "freeze"
         with open(args.sample, "rb") as f:
diff --git a/setup.py b/setup.py
index d18d7cef..ce6ba8c9 100644
--- a/setup.py
+++ b/setup.py
@@ -24,6 +24,7 @@ requirements = [
     "ruamel.yaml==0.17.4",
     "vivisect==1.0.3",
     "smda==1.5.17",
+    "pefile==2021.5.24",
 ]
 
 # this sets __version__
diff --git a/tests/fixtures.py b/tests/fixtures.py
index b93997f2..10b6e36a 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -111,6 +111,13 @@ def get_smda_extractor(path):
     return capa.features.extractors.smda.SmdaFeatureExtractor(report, path)
 
 
+@lru_cache(maxsize=1)
+def get_pefile_extractor(path):
+    import capa.features.extractors.pefile
+
+    return capa.features.extractors.pefile.PefileFeatureExtractor(path)
+
+
 @lru_cache()
 def extract_file_features(extractor):
     features = collections.defaultdict(set)
diff --git a/tests/test_pefile_features.py b/tests/test_pefile_features.py
new file mode 100644
index 00000000..5c24edab
--- /dev/null
+++ b/tests/test_pefile_features.py
@@ -0,0 +1,29 @@
+# Copyright (C) 2020 FireEye, Inc. All Rights Reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at: [package root]/LICENSE.txt
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+#  is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+import sys
+
+import pytest
+from fixtures import *
+from fixtures import parametrize
+
+import capa.features.file
+
+
+@parametrize(
+    "sample,scope,feature,expected",
+    FEATURE_PRESENCE_TESTS,
+    indirect=["sample", "scope"],
+)
+def test_pefile_features(sample, scope, feature, expected):
+    if scope.__name__ != "file":
+        pytest.xfail("pefile only extract file scope features")
+
+    if isinstance(feature, capa.features.file.FunctionName):
+        pytest.xfail("pefile only doesn't extract function names")
+
+    do_test_feature_presence(get_pefile_extractor, sample, scope, feature, expected)
diff --git a/tests/test_smda_features.py b/tests/test_smda_features.py
index de1deebf..85954d99 100644
--- a/tests/test_smda_features.py
+++ b/tests/test_smda_features.py
@@ -14,39 +14,25 @@ from fixtures import parametrize
 import capa.features.file
 
 
-def smda_parametrize(params, valuess, **kwargs):
-    """
-    fixup pytest parametrization to mark a subset of tests as xfail.
-
-    xfail SMDA tests that rely on function id.
-    """
-    ret = []
-    for values in valuess:
-        (sample, scope, feature, expected) = values
-        if scope == "file" and isinstance(feature, capa.features.file.FunctionName) and expected is True:
-            # pytest.param behaves like a list, but carries along associated marks, like xfail.
-            #
-            # https://stackoverflow.com/a/30575822/87207
-            ret.append(pytest.param(*values, marks=pytest.mark.xfail(reason="SMDA has no function ID", strict=True)))
-        elif sample == "a1982..." and sys.platform == "win32":
-            ret.append(pytest.param(*values, marks=pytest.mark.xfail(reason="SMDA bug tracked #585", strict=True)))
-        elif sample == "al-khaser x64" and sys.platform == "win32":
-            ret.append(pytest.param(*values, marks=pytest.mark.xfail(reason="SMDA bug tracked #585", strict=True)))
-        else:
-            ret.append(values)
-    return parametrize(params, ret, **kwargs)
-
-
-@smda_parametrize(
+@parametrize(
     "sample,scope,feature,expected",
     FEATURE_PRESENCE_TESTS,
     indirect=["sample", "scope"],
 )
 def test_smda_features(sample, scope, feature, expected):
+    if scope.__name__ == "file" and isinstance(feature, capa.features.file.FunctionName) and expected is True:
+        pytest.xfail("SMDA has no function ID")
+
+    if sample == "a1982..." and sys.platform == "win32":
+        pytest.xfail("SMDA bug tracked #585")
+
+    if sample == "al-khaser x64" and sys.platform == "win32":
+        pytest.xfail("SMDA bug tracked #585")
+
     do_test_feature_presence(get_smda_extractor, sample, scope, feature, expected)
 
 
-@smda_parametrize(
+@parametrize(
     "sample,scope,feature,expected",
     FEATURE_COUNT_TESTS,
     indirect=["sample", "scope"],