KR20230170976A - 캐퍼빌리티들을 사용하여 메모리에 대한 액세스를 제약하기 위한 기술 - Google Patents

Abstract

캐퍼빌리티들을 사용하여 메모리에 대한 액세스를 제약하기 위한 기술이 제공된다. 메모리에 대한 액세스 요청이 생성되는 동작들을 수행하기 위한 처리 회로부를 갖는 장치가 제공되며, 처리 회로부는 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 액세스 요청들에 대한 메모리 어드레스들을 생성하도록 배열된다. 장치는 또한 처리 회로부가 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 리터럴 풀 내의 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 회로부를 제공하고, 생성된 캐퍼빌리티의 포인터 값은 리터럴 값으로부터 결정된다. 생성된 캐퍼빌리티의 제약 정보는 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택된다. 그러한 접근법은 코드 크기를 감소시키면서 캐퍼빌리티들을 생성하기 위한 견고한 메커니즘을 제공한다는 것이 밝혀졌다.

Description

캐퍼빌리티들을 사용하여 메모리에 대한 액세스를 제약하기 위한 기술

본 기술은 데이터 처리의 분야에 관한 것이며, 보다 구체적으로는 캐퍼빌리티(capability)들을 사용한 메모리에 대한 액세스의 제약에 관한 것이다.

소정 캐퍼빌리티들이 주어진 프로세스에 대해 정의되는 캐퍼빌리티-기반 아키텍처들에 있어서의 관심이 증가하고 있으며, 정의된 캐퍼빌리티들 밖에서 동작들을 수행하려는 시도가 있을 경우 에러가 트리거될 수 있다. 캐퍼빌리티들은 다양한 형태들을 취할 수 있지만, 캐퍼빌리티의 하나의 유형은 ("팻 포인터(fat pointer)"로도 지칭될 수 있는) 유계 포인터(bounded pointer)이다.

예를 들어, 캐퍼빌리티를 참조하여 수행되는 메모리에 대한 액세스들이 캐퍼빌리티로부터 결정된 정의된 영역 내의 메모리 위치들에 관련해서만 그리고 캐퍼빌리티에 의해 또한 정의된 특정 허가 체크들이 충족되는 경우에만 수행될 수 있도록 강제함으로써, 캐퍼빌리티들이 시스템 내에서 보안 제어 조치로서 사용되기 때문에, 캐퍼빌리티들을 생성하는 능력이 엄격하게 제어되는 것이 중요하다.

캐퍼빌리티들을 생성하기 위해 사용될 수 있는 하나의 메커니즘은, 연관된 프로그램 코드를 컴파일할 때 컴파일러가 캐퍼빌리티들을 생성하도록 허용되는 것을 수반하며, 이어서, 생성된 캐퍼빌리티들은, 컴파일된 프로그램 코드와 조합하여, 이어서 비휘발성 메모리에 정적 이미지를 형성하는 리터럴 풀(literal pool)들 내부에 저장된다. 프로그램 코드가 실행될 때, 리터럴 풀에 저장된 컴파일러-생성 캐퍼빌리티들은 이어서, 컴파일된 코드 내의 명령어들을 사용하여 레지스터들에 로딩될 수 있다. 일부 시스템들에서, 일단 캐퍼빌리티가 그러한 레지스터들에 로딩되면, 캐퍼빌리티를 수정하는 것이 가능할 수 있지만, 전형적인 시스템에서, 임의의 수정들은 오직 캐퍼빌리티와 연관된 허가들을 감소시키거나 한계들을 감소시키도록 허용될 것이며, 따라서 원래의 컴파일러-생성 캐퍼빌리티에 비해 감소된 캐퍼빌리티를 초래한다.

캐퍼빌리티들을 생성하기 위해 컴파일러를 사용하는 것은 캐퍼빌리티 생성에 대한 견고한 제어를 가능하게 하지만, 이는 정적 이미지의 코드 크기에 상당한 악영향들을 미칠 수 있다. 특히, 캐퍼빌리티들을 리터럴 풀에 저장하는 것은, 종래의 포인터들에 비해 본질적으로 더 큰 크기의 캐퍼빌리티들로 인해, 그리고 또한 그러한 캐퍼빌리티들과 연관된 정렬 요건들로 인해, 전체 코드 크기를 상당히 증가시킬 수 있다. 많은 저비용 시스템들에서, 디바이스들은 전형적으로 메모리 제약이 있고, 비휘발성 저장소는 중요하며, 따라서, 컴파일러-생성 캐퍼빌리티들의 사용으로부터 초래되는 코드 크기의 증가는 그러한 상황들에서 매력적이지 않다. 따라서, 그러한 캐퍼빌리티들이 생성될 수 있는 방식에 대해 엄격한 수준의 제어를 유지하면서, 그러한 캐퍼빌리티들을 제공하기 위한 개선된 메커니즘을 제공하는 것이 바람직할 것이다.

하나의 예시적인 배열에서, 메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하는 처리 회로부 - 처리 회로부는 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 액세스 요청들에 대한 메모리 어드레스들을 생성하도록 배열됨 -; 및 처리 회로부가 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 리터럴 풀 내의 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 회로부를 포함하고, 생성된 캐퍼빌리티의 포인터 값은 리터럴 값으로부터 결정되고, 생성된 캐퍼빌리티의 제약 정보는 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택되는 장치가 제공된다.

다른 예시적인 배열에서, 메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하는 처리 회로부를 이용하는 단계 - 처리 회로부는 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 액세스 요청들에 대한 메모리 어드레스들을 생성함 -; 및 처리 회로부가 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 메모리의 리터럴 풀 내의 위치로부터 리터럴 값을 검색하는 것 및 생성된 캐퍼빌리티를 도출하는 것을 포함하는 캐퍼빌리티 생성 동작을 수행하는 단계를 포함하고, 생성된 캐퍼빌리티의 포인터 값은 리터럴 값으로부터 결정되고, 생성된 캐퍼빌리티의 제약 정보는 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택되는, 메모리에 대한 액세스를 제약하는 방법이 제공된다.

또한 추가의 예시적인 배열에서, 명령어 실행 환경을 제공하도록 호스트 데이터 처리 장치를 제어하기 위한 컴퓨터 프로그램이 제공되며, 이는, 메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하는 처리 프로그램 로직 - 처리 프로그램 로직은 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 액세스 요청들에 대한 메모리 어드레스들을 생성하도록 배열됨 -; 및 처리 프로그램 로직이 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 리터럴 풀 내의 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 프로그램 로직을 포함하고, 생성된 캐퍼빌리티의 포인터 값은 리터럴 값으로부터 결정되고, 생성된 캐퍼빌리티의 제약 정보는 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택된다. 그러한 컴퓨터 프로그램을 저장하기 위한 컴퓨터 판독가능 매체가 제공될 수 있고, 컴퓨터 판독가능 매체는 비일시적 또는 일시적 형태일 수 있다.

본 기법은 첨부 도면들에 예시된 바와 같은 그의 예들을 참조하여, 단지 예시로서, 추가로 설명될 것이다.
도 1은 하나의 예시적인 구현예에 따른 장치의 블록도이다.
도 2는 유계 포인터 저장 요소들의 세트 내의 포인터 값을 설정하거나 그에 액세스하려는 시도가 있는 경우 에러가 트리거될 수 있는 명령어의 유형들의 예들을 도시하며, 여기서 그 포인터 값은 연관된 범위 정보에 의해 표시된 범위 밖의 어드레스를 특정하는 데 사용된다.
도 3은 하나의 예시적인 구현예에 따른, 유계 포인터들과 연관된 태그 비트의 사용을 예시한다.
도 4는 하나의 예시적인 구현예에 따른, 본 명세서에 설명된 기술들에 따라 사용될 수 있는 캐퍼빌리티의 형태를 개략적으로 예시한다.
도 5는 하나의 예시적인 구현예에 따른, 컴파일러가 리터럴 풀 내에 저장하기 위한 리터럴 값들을 생성하는 데 어떻게 사용될 수 있는지를 개략적으로 예시한다.
도 6은 하나의 예시적인 구현예에 따른, 장치 내에 제공될 수 있는 컴포넌트들을 예시하는 블록도이다.
도 7은 하나의 예시적인 구현예에 따른, 캐퍼빌리티 생성 명령어에 응답하여 수행되는 단계들을 예시하는 흐름도이다.
도 8은 하나의 예시적인 구현예에 따른, 도 7의 단계(275)를 구현하기 위해 수행될 수 있는 단계들을 더 상세히 예시하는 흐름도이다.
도 9는 하나의 예시적인 구현예에 따른, 생성된 캐퍼빌리티의 허가들이 어떻게 결정될 수 있는지를 예시하는 흐름도이다.
도 10은 하나의 예시적인 구현예에 따른, 처리 회로부의 상이한 도메인들 및 처리 상태들의 예를 도시한다.
도 11은 하나의 예시적인 구현예에 따른, 캐퍼빌리티를 생성할 때 수행되는 처리가 생성되는 캐퍼빌리티의 유형에 어떻게 의존할 수 있는지를 예시하는 흐름도이다.
도 12는 하나의 예시적인 구현예에 따른, 단일 캐퍼빌리티 생성 명령어로부터 다수의 캐퍼빌리티들이 어떻게 생성될 수 있는지를 예시하는 흐름도이다.
도 13은 사용될 수 있는 시뮬레이터 예를 도시한다.

본 명세서에 설명된 기술들에 따르면, 메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하기 위한 처리 회로부를 갖는 장치가 제공된다. 처리 회로부는 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 액세스 요청들에 대한 메모리 어드레스들을 생성하도록 배열된다. 처리 회로부에 의해 생성된 메모리 어드레스는 어드레스 변환이 수행되는 시스템들에서의 가상 어드레스일 수 있거나, 대안적으로 어드레스 변환을 지원하지 않는 시스템들에서의 물리 어드레스일 수 있다.

본 명세서에 설명된 기술들에 따르면, 장치는 또한 처리 회로부가 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 리터럴 풀 내의 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 회로부를 제공할 수 있고, 생성된 캐퍼빌리티의 포인터 값은 리터럴 값으로부터 결정된다. 리터럴 값이 포인터 값을 결정하는 데 사용될 수 있지만, 리터럴 값 그 자체는 캐퍼빌리티가 아니고, 대신에 캐퍼빌리티 생성 회로부가 리터럴 값으로부터 포인터 값이 결정되는 캐퍼빌리티를 생성하는 데 사용된다는 점에 유의해야 한다. 캐퍼빌리티를 생성하기 위해, 캐퍼빌리티 생성 회로부는 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따라 제한된 세트의 옵션들로부터 생성된 캐퍼빌리티의 제약 정보를 선택하도록 추가로 배열된다.

그러한 접근법은, 캐퍼빌리티들이 생성되는 것을 가능하게 하며, 그 캐퍼빌리티들은, 컴파일러에 의해 생성되는 캐퍼빌리티들과 동일한 정도로 신뢰될 수 있지만, 컴파일러 생성 캐퍼빌리티들을 통합하는 구현들과 비교할 때 코드 크기에서 상당한 감소를 갖는다는 것이 밝혀졌다. 특히, 생성된 캐퍼빌리티들이 신뢰되는 것과 관련하여, 본 명세서에 설명된 기술들에 따르면, 캐퍼빌리티 생성 회로부는 컴파일된 코드에 의해 제공되는 캐퍼빌리티 생성 명령어를 실행함으로써 캐퍼빌리티를 생성하고, 캐퍼빌리티 생성 회로부는 캐퍼빌리티 생성 명령어에 의해 직접 특정되는 소정 다른 정보와 조합하여, 리터럴 풀로부터의 리터럴 값(즉, 컴파일러에 의해 생성되었을 것이고 정적 이미지의 일부인 값)만을 사용한다. 캐퍼빌리티가 리터럴 풀의 리터럴 값으로부터 생성되고, 리터럴 풀 내에 컴파일러 생성 캐퍼빌리티를 저장하기 위한 요건을 회피하기 때문에, 리터럴 풀의 크기가 상당히 감소될 수 있다. 예를 들어, 리터럴 값은 전형적으로, 대응하는 캐퍼빌리티의 크기에 비해 상당히 감소된 크기인 표준 포인터 값의 크기를 가질 수 있다. 또한, 리터럴 풀 내에 저장된 캐퍼빌리티들과 연관된 정렬 문제들이 더 이상 생성하지 않아서, 추가적인 효율들 및 전체 코드 크기의 추가적인 감소로 이어진다.

그러한 접근법은 많은 시스템들에서 상당한 이익이 있을 수 있다는 것이 밝혀졌다. 예를 들어, 컴파일러에 의해 이전에 생성되었을 수 있는 상당한 수의 요구되는 캐퍼빌리티들이 메모리의 작은 영역에만 액세스하고, 전형적으로 허가들의 소정 제한된 조합들만을 갖는 경우가 종종 있다. 따라서, 캐퍼빌리티의 제약 정보를 형성하는 데 사용되는 범위들 및 허가들의 공통 서브세트는 캐퍼빌리티 생성 회로부에 대한 제한된 세트의 이용가능한 옵션들로서 식별될 수 있으며, 이어서, 그러한 옵션들 중 하나는 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따라 캐퍼빌리티를 생성할 때 선택된다. 따라서, 이는, 정적 이미지 내에서 잠재적으로 많은 수의 컴파일러 생성 캐퍼빌리티들을 특정할 필요성을 회피하고, 대신에, 리터럴 풀 내의 리터럴 값들 및 식별된 제한된 세트의 옵션들로부터 선택된 제약 정보를 사용하여 코드의 실행 동안 그러한 캐퍼빌리티들이 생성되게 허용함으로써, 전체 코드 크기의 상당한 감소들을 허용한다. 위의 방식으로 생성되기 위한 요건들을 충족시키지 않는 임의의 캐퍼빌리티(예컨대, 제한된 세트의 옵션들 내에 속하는 제약 정보를 특정하지 않음)에 대해, 컴파일러-생성 캐퍼빌리티가 대신 리터럴 풀에 저장하기 위한 표준 방식으로 생성될 수 있음에 유의해야 한다.

캐퍼빌리티 생성 회로부는 다양한 형태들을 취할 수 있다. 이는, 예를 들어, 처리 회로부와는 별개의 컴포넌트일 수 있거나, 대안적으로 장치의 처리 회로부 내에 제공될 수 있다.

장치에는 그의 메모리 어드레스가 주어진 캐퍼빌리티를 사용하여 생성되는 주어진 액세스 요청이 그 주어진 캐퍼빌리티에 의해 제공된 제약 정보에 기초하여 허가되는지를 결정하기 위해 캐퍼빌리티 체크 동작을 수행하는 캐퍼빌리티 체크 회로부가 추가로 제공될 수 있다. 캐퍼빌리티 생성 회로부에서와 같이, 캐퍼빌리티 체크 회로부는 처리 회로부와는 별개의 컴포넌트일 수 있거나, 대안적으로 장치의 처리 회로부 내에 제공될 수 있다.

제약 정보가 연관된 캐퍼빌리티에 의해 식별될 수 있는 다수의 방법들이 있다. 예를 들어, 하나의 예시적인 구현예에서 캐퍼빌리티는 제약 정보를 직접 포함할 수 있다. 그러나, 대안적인 구현예에서, 캐퍼빌리티는 대신에 제약 정보가 위치된 메모리 내의 위치를 (직접적으로 또는 간접적으로) 나타낼 수 있다.

캐퍼빌리티 생성 명령어가, 요구된 리터럴 값이 검색될 리터럴 풀 내의 위치를 식별할 수 있는 다수의 방식들이 존재한다. 예를 들어, 베이스 어드레스는 적합한 시스템 레지스터에 제공될 수 있으며, 이어서, 캐퍼빌리티 생성 명령어는 시스템 레지스터에서 특정된 그 베이스 어드레스로부터의 오프셋으로서 사용될 수 있는 즉치 값(immediate value)을 특정한다.

그러나, 하나의 예시적인 구현예에서, 캐퍼빌리티 생성 명령어는, 생성된 캐퍼빌리티의 포인터 값을 결정하는 데 사용될 리터럴 값을 포함하는 리터럴 풀 내의 위치를 식별하기 위해, 현재 프로그램 카운터 값과 조합하여, 캐퍼빌리티 생성 회로부에 의해 사용되는 즉치 값을 특정한다. 이는 특히 효율적인 메커니즘을 제공하는데, 왜냐하면 전형적으로, 컴파일러는 리터럴 값을 소비할 명령어에 가까운 위치에 그 리터럴 값을 저장할 것이고, 따라서 현재 프로그램 카운터 값과 조합하여 사용되는 즉치 값을 특정함으로써, 현재 프로그램 카운터 값이 캐퍼빌리티 생성 명령어를 식별할 것인 경우, 이는 리터럴 풀에서 요구된 리터럴 값의 위치를 식별하기 위한 간단하고 효과적인 메커니즘을 제공하기 때문이다.

즉치 값은 다양한 형태들을 취할 수 있지만, 일 예시에서 구현은 프로그램 카운터 상대 오프셋을 제공하여, 단지 현재 프로그램 카운터 값에 즉치 값을 가산함으로써(또는 그로부터 즉치 값을 감산함으로써) 리터럴 풀 내의 위치가 식별될 수 있게 한다.

생성된 캐퍼빌리티에 대한 제약 정보는 다양한 형태들을 취할 수 있지만, 하나의 예시적인 구현예에서, 생성된 캐퍼빌리티의 포인터 값으로부터 유도된 메모리 어드레스들을 사용하여 액세스가능한 메모리의 영역을 식별하는 한계 정보를 포함하고, 제한된 세트의 옵션들은 한계 정보에 의해 식별된 영역의 제한된 세트의 허용가능한 크기들을 포함한다. 앞서 언급된 바와 같이, 상당한 수의 캐퍼빌리티들은 비교적 작은 구조들에만 액세스할 것을 요구하였고, 따라서 한계 정보에 대한 제한된 세트의 옵션들로서 인코딩될 수 있는 그러한 구조들의 제한된 세트의 가능한 크기들이 존재할 수 있다는 것이 밝혀졌다.

캐퍼빌리티 생성 명령어가, 제한된 세트의 허용가능한 크기들 중 어느 것이 생성될 캐퍼빌리티에 사용될 것인지를 캐퍼빌리티 생성 회로부에 표시할 수 있는 다수의 방식들이 존재한다. 그러나, 하나의 예시적인 구현예에서, 캐퍼빌리티 생성 명령어는, 제한된 세트의 허용가능한 크기들로부터 영역의 크기를 결정하기 위해 캐퍼빌리티 생성 회로부에 의해 사용되는 크기 표시 값을 특정한다. 크기 표시 값은 다양한 형태들을 취할 수 있다. 예를 들어, 이는 크기를 직접 특정할 수 있지만, 대안적으로 임의의 다른 적합한 인코딩이 사용될 수 있다. 예를 들어, 제한된 세트의 허용가능한 크기들은 2의 거듭제곱들만큼 변할 수 있고, 따라서 크기 표시 값은, 생성되는 현재 캐퍼빌리티에 2의 어느 거듭제곱이 적용되는지를 식별할 수 있다. 대안적으로, 크기 표시 값은 미리 결정된 최소 크기에 대한 오프셋을 식별할 수 있다. 따라서, 그 경우, 크기 표시 값은 이어서, 미리 결정된 최소 크기 값에 추가될 수 있는 즉치 값을 효과적으로 형성할 것이다. 이러한 최소 크기 값을 사용함으로써, 이는 다소 더 큰 범위의 유용한 값들이 특정되게 할 수 있다. 예를 들어, 0의 크기 표시 값은 여전히 합리적인 의미를 가지며, 이 경우, 단지 한계 정보에 의해 식별된 액세스가능한 영역에 대한 크기가 미리 결정된 최소 크기여야 한다는 것을 식별한다.

그러나, 제한된 세트의 허용가능한 크기들로부터의 크기의 선택이 캐퍼빌리티 생성 명령어에 의해 제공된 정보로부터 캐퍼빌리티 생성 회로부에 의해 추론될 수 있는 다른 방식들이 존재한다. 예를 들어, 리터럴 값은 포인터 값을 결정하는 데 사용되지 않는 다수의 중복 비트들을 포함할 수 있고, 캐퍼빌리티 생성 회로부는 리터럴 값의 중복 비트들 내에서 제공된 정보로부터 영역의 크기를 결정하도록 배열될 수 있다. 예를 들어, 리터럴 값으로부터 결정된 포인터 값들에 사용되는 일부 레벨의 정렬이 있을 수 있으며, 이는 생성된 캐퍼빌리티에 대한 포인터 값을 형성하기 위해 로딩된 리터럴 값의 특정 수의 최하위 비트들이 요구되지 않음을 의미할 것이다. 이러한 경우들에서, 그러한 중복 비트들은 대신에, 생성된 캐퍼빌리티의 제약 정보에 의해 식별될 영역의 크기를 인코딩하는 데 사용될 수 있다.

중복 비트들의 수는 미리 결정될 수 있지만, 대안적인 구현예에서 중복 비트들의 수는 변할 수 있다. 예를 들어, 캐퍼빌리티 생성 회로부는, 리터럴 값을 형성하는 데 사용되는 인코딩 방식에 따라, 포인터 값을 결정하는 데 사용되는 비트들을 특정하는 제1 부분과 중복 비트들을 포함하는 제2 부분 사이의 리터럴 값 내의 경계를 결정하도록 배열될 수 있다. 특정 예로서, 그러한 방식으로 리터럴 값 내에서 크기 및 포인터 값 정보 둘 모두를 인코딩하기 위해 삼각 인코딩의 형태가 사용될 수 있다.

일단 크기 정보가 결정되면, 캐퍼빌리티 생성 명령어 내에 특정된 정보로부터 한계 정보가 결정될 수 있는 다수의 방식들이 존재한다. 그러나, 하나의 예시적인 구현예에서, 한계 정보는 포인터 값으로부터 결정된 제1 한계, 및 제1 한계로부터 결정된 제2 한계 및 제한된 세트의 허용가능한 크기들로부터 결정된 영역의 크기를 식별한다. 이는, 포인터 값을 사용하여 제1 한계를 효과적으로 결정한 다음, 크기 정보를 사용하여 제1 한계로부터 제2 한계를 결정함으로써, 한계 정보를 식별하기 위한 효율적인 메커니즘을 제공한다. 포인터 값으로부터 제1 한계가 결정되는 방법은 구현에 따라 변할 수 있지만, 하나의 특정 예시적인 구현예에서, 제1 한계는 포인터 값과 동일하게 설정된다.

하나의 예시적인 구현예에서, 제약 정보는 메타데이터의 항목들을 포함할 수 있고, 제한된 세트의 옵션들은 메타데이터의 항목들에 대한 제한된 세트의 가능한 값들을 포함한다. 따라서, 하나의 예시적인 구현예에서, 제약 정보는 앞서 언급한 한계 정보 및 메타데이터의 추가적인 항목들 둘 모두를 포함할 수 있다. 메타데이터의 항목들은 다양한 형태들을 취할 수 있지만, 하나의 예시적인 구현예에서, 적어도, 생성된 캐퍼빌리티의 허용가능한 사용들을 식별하는 복수의 허가 표시들을 포함할 수 있고, 제한된 세트의 옵션들은 복수의 허가 표시들에 의해 표시될 수 있는 허가들의 제한된 세트의 허용된 조합들을 포함한다. 예를 들어, 대부분의 경우들에서, 허가들은, 캐퍼빌리티 내의 연관된 포인터가 메모리로부터 데이터를 판독하기 위한 어드레스들을 생성하는 데에만 사용될 수 있다는 것을 나타내거나, 또는 대신에 포인터가 판독 및 기입 액세스들 둘 모두를 수행하는 데 사용될 수 있음을 식별할 수 있다. 이어서, 허가들의 제한된 세트의 허용된 조합들의 경우, 그 제한된 세트의 옵션들 내로부터의 선택은 캐퍼빌리티 생성 명령어에 의해 제공된 정보 내에서 효율적으로 인코딩될 수 있다.

메타데이터의 항목들에 주어질 값들이 캐퍼빌리티 생성 회로부에 의해 캐퍼빌리티 생성 명령어로부터 결정될 수 있는 많은 상이한 방식들이 존재한다. 예를 들어, 캐퍼빌리티 생성 명령어는 메타데이터의 항목들 중 하나 이상에 대한 값들을 결정하기 위해 캐퍼빌리티 생성 회로부에 의해 사용되는 메타데이터 정보를 특정할 수 있다. 그러한 메타데이터 정보는 다수의 상이한 방식들로 제공될 수 있고, 하나의 예시적인 구현예에서, 예를 들어, 메타데이터의 연관된 항목들에 대해 사용될 값들을 직접 식별하거나 제한된 세트의 옵션들 중 어느 것을 선택할지를 식별할 수 있는 하나 이상의 즉치 값들의 형태를 취할 수 있다. 대안적으로, 상이한 플래그 값들이 명령어에서 특정될 수 있거나, 또는 캐퍼빌리티 생성 명령어의 상이한 변형들이 정보를 정의하는 상이한 메타데이터를 식별하는 데 사용될 수 있다.

대안으로서, 또는 추가적으로, 장치는 메타데이터의 항목들 중 하나 이상에 대한 값들을 결정하기 위해 캐퍼빌리티 생성 회로부에 의해 참조되는 제어 레지스터를 더 포함할 수 있다. 제어 레지스터는 다양한 형태들을 취할 수 있고, 하나의 예시적인 구현예에서 시스템 구성 레지스터일 수 있다.

메타데이터의 항목들 중 하나 이상에 대한 값들이 결정될 수 있는 방법의 다른 대안적인 또는 추가적인 예로서, 리터럴 값은 앞서 언급한 바와 같이, 포인터 값을 결정하는 데 사용되지 않는 다수의 중복 비트들을 포함할 수 있다. 이러한 구현들에서, 처리 회로부는 리터럴 값의 중복 비트들 내에 제공된 정보로부터 메타데이터의 항목들 중 하나 이상에 대한 값들을 결정하도록 배열될 수 있다.

캐퍼빌리티 생성 명령어에 의해 특정된 정보에 기초하여 메타데이터의 하나 이상의 항목들에 대한 값들이 결정되는 방식은 하나 이상의 인자들에 따라 변할 수 있다. 예를 들어, 그러한 결정은 처리 회로부의 현재 동작 모드에 의존할 수 있다. 따라서, 메타데이터의 항목들의 값들을 결정하는 데 사용되는 정보를 제공하기 위해 위의 옵션들 중 어느 것이 사용되는지에 관계없이, 그 정보가 해석되는 방식은 처리 회로부의 현재 동작 모드에 의존할 수 있다. 다른 대안으로서, 제어 레지스터가 캐퍼빌리티 생성 회로부에 의해 참조되는 경우, 그 제어 레지스터는 처리 회로부의 현재 동작 모드에 따라 상이한 정보를 제공할 수 있다.

메타데이터의 항목들에 대한 값들이 결정될 수 있는 방법에 대한 위의 상이한 예들 모두는 독립적으로 또는 조합하여 사용될 수 있다는 점에 유의해야 한다. 예를 들어, 메타데이터의 하나 이상의 항목들은 하나의 기술을 사용하여 결정된 자신들의 값들을 가질 수 있는 반면, 메타데이터의 다른 항목들은 다른 기술들 중 하나를 사용하여 결정된 자신들의 값들을 가질 수 있다.

앞서 언급된 바와 같이, 생성된 캐퍼빌리티 내에서 제공될 수 있는 메타데이터의 유형들 중 하나는 복수의 허가 표시들을 포함할 수 있다. 하나의 예시적인 구현예에서, 캐퍼빌리티 생성 회로부는 생성된 캐퍼빌리티의 유형에 따라 복수의 허가 표시들에 의해 나타내기 위한 허가들의 조합을 결정하도록 배열될 수 있다. 특히, 적절한 제한된 세트의 허가 조합들은 생성되는 캐퍼빌리티의 유형에 의존할 수 있고, 그에 따라서, 생성된 캐퍼빌리티의 유형을 고려함으로써, 허가들의 조합을 결정하기 위해 제공된 정보는 생성되는 캐퍼빌리티의 유형에 따라 상이하게 해석될 수 있다.

생성된 캐퍼빌리티의 유형이 결정될 수 있는 다수의 방식들이 존재한다. 예를 들어, 캐퍼빌리티 생성 명령어는 전형적으로, 생성된 캐퍼빌리티가 저장될 목적지 캐퍼빌리티 저장 요소를 특정할 것이고, 캐퍼빌리티 생성 회로부는 특정된 목적지 캐퍼빌리티 저장 요소로부터 생성된 캐퍼빌리티의 유형을 추론하도록 배열될 수 있다. 예를 들어, 목적지 캐퍼빌리티 저장 요소는 범용 캐퍼빌리티 저장 요소일 수 있거나 또는 프로그램 카운터 캐퍼빌리티 저장 요소일 수 있으며, 허가들의 결정된 조합은, 범용 캐퍼빌리티가 생성되고 있는지 또는 프로그램 카운터 캐퍼빌리티가 생성되고 있는지에 의존할 수 있다.

예를 들어, 범용 캐퍼빌리티의 경우, 실행가능한 허가가 설정되지 않는 경우가 전형적일 수 있는 반면, 프로그램 카운터 캐퍼빌리티의 경우, 실행가능한 허가가 설정될 수 있다. 특히, 실행가능한 허가 비트는, 캐퍼빌리티가 페치 및 실행될 명령어들에 대한 메모리 어드레스들을 생성하는 데 사용될 수 있는지 여부를 나타낼 수 있으며, 이러한 허가는 전형적으로 프로그램 카운터 캐퍼빌리티에 적절할 수 있지만, 전술된 기법들을 사용하여 생성된 범용 캐퍼빌리티들에 대해서는 적절하지 않을 수 있다.

전형적으로, 캐퍼빌리티 생성 명령어를 실행할 때 호출되는 처리는, 특정된 목적지 캐퍼빌리티 저장 요소 내에 생성된 캐퍼빌리티를 저장하는 것으로 종료될 것이다. 그러나, 하나의 예시적인 구현예에서, 특정된 목적지 캐퍼빌리티 저장 요소가 프로그램 카운터 캐퍼빌리티를 저장하는 데 사용되는 프로그램 카운터 캐퍼빌리티 저장 요소일 때, 처리 회로부는, 생성된 캐퍼빌리티가 프로그램 카운터 캐퍼빌리티 저장 요소에 저장되면, 또한 프로그램 실행을 생성된 캐퍼빌리티를 사용하여 식별된 타겟 명령어로 분기하게 하도록 배열될 수 있다. 이는, 캐퍼빌리티 생성 명령어에 후속하는 후속 분기 명령어를 특정할 필요성을 회피함으로써 코드 밀도를 개선할 수 있다.

원하는 경우, 전술된 캐퍼빌리티 생성 기능은 특정 유형들의 캐퍼빌리티로 제한될 수 있다. 예로서, 일 구현예에서, 프로그램 카운터 캐퍼빌리티들을 생성하기 위한 그러한 캐퍼빌리티 생성 명령어들의 사용이 방지될 수 있다. 특정 예로서, 캐퍼빌리티 생성 회로부는, 캐퍼빌리티 생성 명령어에 대한 특정된 목적지 캐퍼빌리티 저장 요소가 프로그램 카운터 캐퍼빌리티 저장 요소인 경우 결함을 트리거하도록 배열될 수 있다.

하나의 예시적인 구현에서, 캐퍼빌리티 생성 회로부는 캐퍼빌리티 생성 명령어의 단일 인스턴스에 응답하여 다수의 캐퍼빌리티들을 생성하도록 배열될 수 있다. 따라서, 캐퍼빌리티 생성 명령어가 실행될 때, 캐퍼빌리티 생성 회로부는 위에서 참조된 생성된 캐퍼빌리티뿐만 아니라 하나 이상의 추가로 생성된 캐퍼빌리티들을 도출할 수 있다. 각각의 추가로 생성된 캐퍼빌리티에 대해, 캐퍼빌리티 생성 회로부는, 캐퍼빌리티 생성 명령어에 의해 식별된 위치로부터 오프셋되는, 리터럴 풀 내의 연관된 위치로부터 획득된 연관된 리터럴 값으로부터 그 추가로 생성된 캐퍼빌리티에 대한 포인터 값을 결정하도록 배열될 수 있다. 따라서, 캐퍼빌리티 생성 명령어는 여전히 단일 리터럴 값의 위치를 식별할 수 있고, 그 리터럴 값은 처음 생성된 캐퍼빌리티에 대한 포인터 값을 결정하는 데 사용되지만, 이어서 추가로 생성된 캐퍼빌리티 각각에 대해 사용될 리터럴 값들의 위치들은 처음 생성된 캐퍼빌리티에 대한 리터럴 값에 대해 결정된 위치로부터 추론될 수 있다. 오프셋들은, 그들이 캐퍼빌리티 생성 명령어에 의해 특정될 필요가 없도록 미리 결정될 수 있거나, 또는 대안적으로, 원하는 경우, 오프셋들에 관한 정보가 명령어 내에서 인코딩될 수 있다.

캐퍼빌리티 생성 명령어의 단일 인스턴스에 응답하여 도출된 다양한 생성된 캐퍼빌리티들에 대한 제약 정보가 추론될 수 있는 다수의 방식들이 존재하지만, 하나의 예시적인 구현예에서, 캐퍼빌리티 생성 회로부는 생성된 캐퍼빌리티 및 동일한 제약 정보를 갖는 각각의 추가로 생성된 캐퍼빌리티를 도출하도록 배열된다. 따라서, 캐퍼빌리티 생성 명령어의 실행이 다수의 캐퍼빌리티들의 도출을 초래할 상황들에서, 제약 정보를 특정하도록 요구되는 명령어 내의 인코딩 공간이 증가될 필요가 없다.

이어서, 생성된 캐퍼빌리티들 각각이 저장될 목적지 캐퍼빌리티 저장 요소들과 관련하여, 캐퍼빌리티 생성 회로부는, 초기 생성된 캐퍼빌리티에 대한 목적지로서 사용되는 특정된 목적지 캐퍼빌리티 저장 요소로부터, 각각의 추가로 생성된 캐퍼빌리티에 대한 연관된 목적지 캐퍼빌리티 저장 요소를 유도하도록 배열될 수 있다. 예를 들어, 요구된 목적지 캐퍼빌리티 저장 요소들은 특정된 목적지 캐퍼빌리티 저장 요소로부터 시작하는 캐퍼빌리티 저장 요소들의 연속적인 시퀀스를 형성할 수 있다. 대안적인 접근법으로서, 원하는 경우, 각각의 목적지 캐퍼빌리티 저장 요소가 명령어에서 명시적으로 식별될 수 있다.

처리 회로부는 다수의 상이한 동작 모드들에서 동작하도록 배열될 수 있다. 이러한 동작 모드들은 다양한 형태들을 취할 수 있다. 예를 들어, 처리 회로부는 보안 도메인 또는 하위 보안 도메인에서 그리고/또는 특권화된 상태 또는 비특권화된 상태 내에서 동작할 수 있으며, 실제로, 처리 회로부에 의해 채택될 수 있는 2개 초과의 도메인들 및/또는 2개 초과의 상태들이 존재할 수 있다. 처리 회로부의 현재 동작 모드는 처리 회로부가 동작하고 있는 도메인 및 처리 상태 둘 모두에 의존할 수 있다.

원하는 경우, 캐퍼빌리티 생성 회로부의 동작은 처리 회로부의 현재 동작 모드에 의존할 수 있다. 이는, 예를 들어, 캐퍼빌리티들을 생성하는 능력을 처리 회로부의 특정 동작 모드들로 제한하는 데 사용될 수 있다. 따라서, 예로서, 처리 회로부가 이러한 방식의 캐퍼빌리티들의 생성이 금지되는 특정 동작 모드에 있는 동안 캐퍼빌리티 생성 명령어를 실행하도록 캐퍼빌리티 생성 회로부가 트리거되면, 결함이 제기될 수 있다.

캐퍼빌리티 생성 회로부의 동작이 현재 동작 모드에 의존하게 될 수 있는 방법의 다른 예들로서, 생성된 메타데이터의 형태는 동작 모드에 따라 변할 수 있다. 예를 들어, 메타데이터는 캐퍼빌리티가 생성된 시점에 처리 회로부의 동작 모드를 나타내는 정보를 포함할 수 있으며, 따라서 캐퍼빌리티 생성 회로부는 캐퍼빌리티 생성 명령어가 실행된 시점에 처리 회로부의 현재 동작 모드에 따라 상이한 형태들의 메타데이터를 생성할 것이다. 또한 추가의 예로서, 처리 회로부는, 캐퍼빌리티들에 의해 제한되는 캐퍼빌리티 모드 및 캐퍼빌리티들에 의해 제한되지 않는 추가 모드로 동작할 수 있으며, 캐퍼빌리티 생성 회로부가 캐퍼빌리티 생성 명령어들에 응답하여 동작하는 방식은, 처리 회로부가 캐퍼빌리티 모드에서 동작하고 있는지 여부에 의존할 수 있다.

이제 도면들을 참조하여 특정 예들이 설명될 것이다.

본 명세서에 설명된 기술들은 다양한 데이터 처리 시스템들에서, 그리고 그러한 시스템들 내의 상이한 유형의 처리 회로부와 연관하여 이용될 수 있다. 예를 들어, 기술들은 중앙 처리 유닛(CPU)의 형태를 취하는 처리 회로부와 관련하여 사용될 수 있지만, 대안적으로, 직접 메모리 액세스(DMA) 제어기, 암호화 가속기 등과 같은 다른 처리 회로부와 관련하여 이용될 수 있다. 순전히 다음의 도 1의 예시적인 예로서, CPU의 처리 파이프라인이 설명된 기술들이 사용될 수 있는 처리 회로부의 예로서 고려될 것이다.

도 1은 명령어들을 처리하기 위한 처리 파이프라인(4)을 포함하는 데이터 처리 장치(2)의 예를 개략적으로 예시한다. 이러한 예에서, 처리 파이프라인(4)은 페치 스테이지(6), 디코드 스테이지(8), 발행 스테이지(10), 실행 스테이지(12), 및 라이트백 스테이지(write back stage)(14)를 포함하는 다수의 파이프라인 스테이지들을 포함하지만, 다른 유형들 또는 조합들의 스테이지들이 제공될 수 있다는 것이 인식될 것이다. 예를 들어 레지스터 재명명을 수행하기 위한 재명명 스테이지가 몇몇 예시적인 구현예에서 포함될 수 있다. 처리될 명령어들은 스테이지로부터 스테이지로 이동하고, 한 명령어가 하나의 스테이지에서 보류 중인 동안, 다른 명령어는 파이프라인(4)의 상이한 스테이지에서 보류 중일 수 있다.

페치 스테이지(6)는 레벨 1(L1) 명령어 캐시(20)로부터 명령어들을 페치한다. 페치 스테이지(6)는 보통 연속적인 명령어 어드레스들로부터 순차적으로 명령어들을 페치할 수 있다. 그러나, 페치 스테이지는 또한 분기 명령어들의 결과를 예측하기 위한 분기 예측기(22)를 가질 수 있고, 페치 스테이지(6)는, 분기가 취해질 것으로 예측되는 경우에는 (비-순차적인) 분기 타겟 어드레스로부터, 또는 분기가 취해지지 않을 것으로 예측되는 경우에는 다음의 순차적인 어드레스로부터 명령어들을 페치할 수 있다. 분기 예측기(22)는 소정의 분기들이 취해질 가능성이 있는지 또는 아닌지 여부를 예측하기 위한 정보를 저장하기 위한 하나 이상의 분기 이력 테이블들을 포함할 수 있다. 예를 들어, 분기 이력 테이블들은 이전에 실행된 분기들의 실제 결과들을 추적하거나 분기들에 대해 이루어진 예측의 신뢰도를 표현하기 위한 카운터들을 포함할 수 있다. 분기 예측기(22)는 또한 분기 명령어들의 이전 타겟 어드레스들을 캐싱하기 위한 분기 타겟 어드레스 캐시(branch target address cache, BTAC)(24)를 포함할 수 있으며, 이에 따라, 이들이 동일한 분기 명령어들의 후속적인 발생들 시에 예측될 수 있다.

페치된 명령어들은, 디코딩된 명령어들을 생성하기 위해 명령어들을 디코딩하는 디코드 스테이지(8)에 전달된다. 디코딩된 명령어들은 적절한 처리 동작들을 실행하도록 실행 스테이지(12)를 제어하기 위한 제어 정보를 포함할 수 있다. 캐시(20)로부터 페치된 몇몇 더 복잡한 명령어들에 대해, 디코드 스테이지(8)는 그러한 명령어들을 마이크로 동작들(μop들 또는 uop들)로 알려져 있을 수 있는 다수의 디코딩된 명령어들에 매핑할 수 있다. 따라서, L1 명령어 캐시(20)로부터 페치된 명령어들과 파이프라인의 나중의 스테이지들에 의해 보여지는 것과 같은 명령어들 사이에 일대일 관계가 없을 수 있다. 일반적으로, 본 출원에서 "명령어들"에 대한 언급은 마이크로 동작들을 포함하는 것으로 해석되어야 한다.

디코딩된 명령어들은 발행 스테이지(10)로 전달되며, 이는 명령어들의 실행에 요구되는 피연산자들이 이용가능한지 여부를 결정하고, 피연산자들이 이용가능할 때 실행할 명령어들을 발행한다. 몇몇 예시적인 구현예들은 순서에 맞는(in-order) 처리를 지원할 수 있으며, 이에 따라, 명령어들은, 명령어들이 L1 명령어 캐시(20)로부터 페치되었던 프로그램 순서에 대응하는 순서로 실행되도록 발행된다. 다른 예시적인 구현예들은 순서에 맞지 않는(out-of-order) 실행을 지원할 수 있으며, 이에 따라, 명령어들은 프로그램 순서와는 상이한 순서로 실행 스테이지(12)로 발행될 수 있다. 순서에 맞지 않는 처리는 성능을 개선하는 데 유용할 수 있는데, 그 이유는, 이전 명령어가 피연산자들을 기다리면서 연기(stall)되는 동안, 프로그램 순서 내의 피연산자들이 이용가능한 나중의 명령어가 먼저 실행될 수 있기 때문이다.

발행 스테이지(10)는, 명령어들이 다양한 데이터 처리 동작들을 수행하기 위해 실행되는, 실행 스테이지(12)로 명령어들을 발행한다. 예를 들어 실행 스테이지는 정수 값들에 대해 산술 또는 논리 연산들을 수행하기 위한 산술/논리 유닛(ALU)(30), 부동 소수점 형태로 표현된 값들에 대한 연산들을 수행하기 위한 부동 소수점(FP) 유닛(32), 및 레벨 1(L1) 데이터 캐시(36)로부터 레지스터(40)로 데이터 값을 로딩하기 위한 로드 동작들 또는 레지스터(40)로부터 L1 데이터 캐시(36)로 데이터 값을 저장하기 위한 저장 동작들을 수행하기 위한 로드/저장 유닛(34)을 포함하는 다수의 실행 유닛들(30, 32, 34)을 포함할 수 있다. 이들은 단지 제공될 수 있는 실행 유닛들의 유형들의 몇몇 예들일 뿐이고, 많은 다른 종류들이 또한 제공될 수 있다는 것이 인식될 것이다. 처리 동작들을 수행하기 위해, 실행 스테이지(12)는 레지스터들(40)의 세트로부터 데이터 값들을 판독할 수 있다. 이어서, 실행된 명령어들의 결과들이 라이트백 스테이지(14)에 의해 레지스터들(40)에 라이트백될 수 있다.

L1 명령어 캐시(20) 및 L1 데이터 캐시(36)는 다수의 레벨들의 캐시들을 포함하는 캐시 계층구조의 일부일 수 있다. 예를 들어, 레벨 2(L2) 캐시(44)가 또한 제공될 수 있고, 선택적으로 추가 레벨들의 캐시가 제공될 수 있다. 이러한 예에서, L2 캐시(44)는 L1 명령어 캐시(20)와 L1 데이터 캐시(36) 사이에서 공유되지만, 다른 예들은 별개의 L2 명령어 및 데이터 캐시들을 가질 수 있다. 페치될 명령어가 L1 명령어 캐시(20)에 있지 않을 때, 그것은 L2 캐시(44)로부터 페치될 수 있고, 유사하게 명령어가 L2 캐시(44)에 있지 않은 경우, 그것은 메인 메모리(50)로부터 페치될 수 있다. 유사하게, 로드 명령어들에 응답하여, 데이터가 L1 데이터 캐시(36)에 있지 않은 경우, 그것은 L2 캐시(44)로부터 페치될 수 있고, 요구되는 경우, 메모리(50)로부터 페치될 수 있다. 캐시 계층구조를 관리하기 위해 임의의 알려진 방식이 사용될 수 있다.

프로그램 명령어들 및 데이터 값들을 참조하기 위해 파이프라인(4)에 의해 사용되는 어드레스들은 가상 어드레스들일 수 있지만, 적어도 메인 메모리(50), 및 선택적으로 또한 적어도 몇몇 레벨들의 캐시 계층구조는 물리적으로 어드레싱될 수 있다. 따라서, 파이프라인(4)에 의해 사용되는 가상 어드레스들을 캐시 또는 메모리에 액세스하는 데 사용되는 물리 어드레스들로 변환하기 위해 변환 색인 버퍼(52)(TLB)가 제공될 수 있다. 예를 들어, TLB(52)는, 대응하는 페이지 내의 가상 어드레스들을 물리 어드레스들로 변환하기 위해, 가상 어드레스 공간의 대응하는 페이지의 가상 페이지 어드레스 및 가상 페이지 어드레스가 매핑되어야 하는 대응하는 물리 페이지 어드레스를 각각 특정하는 다수의 엔트리들을 포함할 수 있다. 예를 들어, 가상 및 물리 페이지 어드레스들은 대응하는 가상 및 물리 어드레스들의 최상위 부분에 대응할 수 있으며, 이때 나머지 최하위 부분은 가상 어드레스를 물리 어드레스로 매핑할 때 변경되지 않는 채로 유지된다. 어드레스 변환 정보뿐만 아니라, 각각의 TLB 엔트리는 또한, 어드레스들의 소정 페이지들이 파이프라인(4)의 소정 모드들에서 액세스가능한지 여부를 나타내는 것과 같은 액세스 허가들을 특정하는 어떤 정보를 포함할 수 있다. 몇몇 예시적인 구현예들에서, TLB 엔트리들은 또한, 캐시 계층구조의 어떤 레벨들이 판독 또는 기입 동작들에 응답하여 업데이트되는지(예를 들어, 캐시가 라이트백 모드 또는 라이트스루 모드(write through mode)에서 동작해야 하는지 여부)를 정의하는 캐시 정책 정보 또는 대응하는 페이지 내의 어드레스들에 대한 데이터 액세스들이 파이프라인(4)에 의해 데이터 액세스들이 발행되었던 순서와 비교하여 메모리 시스템에 의해 재순서화될 수 있는지 여부를 정의하는 정보와 같은 어드레스들의 대응하는 페이지의 다른 특성들을 정의할 수 있다.

도 1이 단일 레벨 TLB(52)를 도시하고 있지만, 레벨 1(L1) TLB(52)가 다수의 최근에 액세스된 페이지 내의 어드레스들을 변환하기 위한 TLB 엔트리들을 포함할 수 있고, 레벨 2(L2) TLB가 더 많은 수의 페이지에 대한 엔트리들을 저장하기 위해 제공될 수 있도록, TLB들의 계층구조가 제공될 수 있다는 것이 인식될 것이다. 요구되는 엔트리가 L1 TLB에 존재하지 않을 때, 그것은 L2 TLB로부터, 또는 계층구조 내의 추가의 TLB들로부터 페치될 수 있다. 액세스될 페이지에 대해 요구되는 엔트리가 TLB들 중 어느 것에도 없는 경우, 페이지 테이블 워크(page table walk)가 메모리(50) 내의 페이지 테이블들에 액세스하기 위해 수행될 수 있다. 임의의 알려진 TLB 관리 방식이 본 기술에서 사용될 수 있다.

또한, 몇몇 시스템들은, 예를 들어 제1 TLB(또는 TLB들의 계층구조)가 가상 어드레스들을 중간 어드레스들로 변환하는 데 사용될 수 있고, 하나 이상의 추가 TLB(들)를 사용하는 제2 레벨의 어드레스 변환이 이어서 중간 어드레스들을 캐시 또는 메모리에 액세스하는 데 사용되는 물리 어드레스들로 변환할 수 있도록, 다수의 레벨의 어드레스 변환을 지원할 수 있다는 것이 인식될 것이다. 이것은 가상화를 지원하는 데 유용할 수 있으며, 여기서, 예를 들어, 제1 레벨의 어드레스 변환은 운영 체제에 의해 관리될 수 있고, 제2 레벨의 어드레스 변환은 하이퍼바이저(hypervisor)에 의해 관리될 수 있다.

장치에는 캐퍼빌리티들을 저장하기 위한 캐퍼빌리티 저장 요소들(이는, 캐퍼빌리티가 포인터를 사용할 때 어드레스들의 허용가능한 범위를 나타내는 연관된 범위 정보를 갖는 유계 포인터의 형태를 취할 때, 유계 포인터 저장 요소들로 지칭될 수 있음)이 제공될 수 있다. 각각의 캐퍼빌리티/유계 포인터 저장 요소는 레지스터, 또는 범용 메모리 내의 메모리 위치, 예컨대 스택 메모리 상의 위치일 수 있다.

도 1에 도시된 바와 같이, 장치(2)는 유계 포인터 저장 요소들로서 사용되는 유계 포인터 레지스터들(60)의 세트를 가질 수 있다. 유계 포인터 레지스터들의 세트가 범용 데이터 레지스터들(40)의 세트에 대해 물리적으로 별개인 것으로 도 1에 도시되어 있지만, 하나의 예시적인 구현예에서, 동일한 물리 저장소를 사용하여 범용 데이터 레지스터들 및 유계 포인터 레지스터들 둘 모두를 제공할 수 있다.

각각의 유계 포인터 레지스터(60)는 액세스될 데이터 값의 어드레스를 결정하는 데 사용될 수 있는 포인터 값(62), 및 대응하는 포인터(62)를 사용할 때 허용가능한 어드레스들의 범위를 특정하는 범위 정보(64)를 포함한다. 유계 포인터 레지스터(60)는 또한 포인터의 사용에 대한 하나 이상의 제한들/허가들을 정의할 수 있는 제한 정보(66)(본 명세서에서 허가 정보로도 지칭됨)를 포함할 수 있다. 예를 들어, 제한(66)은 포인터(62)를 사용할 수 있는 명령어들의 유형들, 또는 포인터가 사용될 수 있는 파이프라인(4)의 모드들을 제한하는 데 사용될 수 있다. 따라서, 범위 정보(64) 및 제한 정보(66)는 포인터(62)가 사용되도록 허용되는 캐퍼빌리티들을 정의하는 것으로 간주될 수 있다. 정의된 캐퍼빌리티들 밖에서 포인터(62)를 사용하려는 시도가 이루어질 때, 에러가 트리거될 수 있다. 범위 정보(64)는, 예를 들어, 포인터들이 소정의 알려진 경계들 내에 유지되고, 민감한 또는 보안 정보를 포함할 수 있는 메모리 어드레스 공간의 다른 영역들로 벗어나지 않는 것을 보장하는 데 유용할 수 있다. 동일한 물리 저장소가 범용 데이터 레지스터들 및 유계 포인터 레지스터들 둘 모두에 대해 사용되는 예시적인 구현예에서, 포인터 값(62)은, 예를 들어, 대응하는 범용 레지스터에 사용되는 바와 동일한 저장 위치 내에 저장될 수 있다.

도 2는 허용가능한 범위가 데이터 또는 명령어들에 대한 인가되지 않은 액세스에 대해 보호하는 데 사용되는 명령어들의 유형들의 예를 도시한다. 도 2의 상부 부분에 도시된 바와 같이, 특정한 유계 포인터 레지스터(PR1)는 주어진 포인터 값(62) 및 범위 정보(64)를 포함하며, 이는, 이러한 예에서, 허용가능한 범위의 하계(lower bound)를 정의하는 하계 어드레스(68) 및 허용가능한 범위의 상계(upper bound)를 정의하는 상계 어드레스(69)를 사용하여 특정된다. 예를 들어, 경계들(68, 69)은 어드레스 80000 내지 어드레스 81000의 범위를 정의하도록 설정된다. 에러들은, 소정 명령어들이 유계 포인터 레지스터(PR1)를 참조하고 포인터(62)로부터 결정된 어드레스가 이러한 범위 밖에 있을 때 트리거될 수 있다.

예를 들어, 도 2의 부분 A에 도시된 바와 같이, 몇몇 시스템들에서, 포인터 레지스터(60) 내의 포인터(62)의 값을 범위 정보(64)에 의해 특정된 범위 밖에 놓인 값으로 설정하려는 시도가 있는 경우 (여기서 포인터는 어드레스를 직접 특정한다고 가정됨) 에러가 트리거될 수 있다. 이것은 포인터(62)가 특정된 범위 밖의 임의의 값을 취하는 것을 회피하며, 이에 따라, 포인터를 사용하는 임의의 액세스들은 허용된 범위 내에 안전하게 놓이도록 보장될 수 있게 된다. 대안적으로, 도 2의 부분 B에 도시된 바와 같이, 포인터(62)의 어드레스가 특정된 범위 밖에 놓일 경우, 명령어가 그러한 어드레스에 의해 식별된 위치에 액세스하려고 시도할 때 에러가 트리거될 수 있다. 따라서, 포인터(62)를 특정된 범위 밖의 값으로 설정하는 것이 여전히 허용가능할 수 있지만, 일단 포인터 어드레스(또는 포인터로부터 유도되는 어드레스)에서의 데이터 액세스가 시도되면, 어드레스가 허용된 범위 밖에 놓이는 경우, 에러가 트리거될 수 있다. 다른 시스템들은 도 2의 부분 A 및 부분 B에 도시된 명령어의 유형들 둘 모두에 응답하여 에러들을 트리거할 수 있다.

범위 정보(64)는 상이한 방식들로 설정될 수 있다. 예를 들어, 보안 코드, 또는 운영 체제 또는 하이퍼바이저가 주어진 포인터에 대해 허용되는 범위를 특정할 수 있다. 예를 들어, 명령어 세트 아키텍처는 주어진 포인터(62)에 대한 범위 정보(64)를 설정하거나 수정하기 위한 다수의 명령어들을 포함할 수 있고, 이러한 명령어들의 실행은 소정 소프트웨어, 또는 프로세서(4)의 소정 모드들이나 예외 상태들로 제한될 수 있다. 범위 정보(64)를 설정하거나 수정하기 위한 임의의 알려진 기술이 사용될 수 있다.

포인터를 참조하는 소정의 명령어들을 실행할 때 실행 상태(12)에서 사용될 수 있는 유계 포인터 저장 요소들(60)의 세트에 더하여, 프로그램 카운터 캐퍼빌리티(program counter capability, PCC) 레지스터(80)가, 명령어들이 레벨 1 명령어 캐시(20)로부터 페치되고 있을 때, 페치 스테이지(6)에서 유사한 기능을 제공하기 위해 또한 사용될 수 있다. 특히, 프로그램 카운터 포인터는 필드(82)에 저장될 수 있으며, 이때, PCC(80)는 또한, 유계 포인터 저장 요소들(60)의 세트 내의 포인터들 각각과 함께 제공되는 범위 및 제한 정보와 유사한, 범위 정보(84) 및 임의의 적절한 제한 정보(86)를 제공한다.

도 3은, 개별 데이터 블록들이 캐퍼빌리티(즉, 유계 포인터 및 연관된 제한 정보)를 표현하는지 또는 정상 데이터를 표현하는지를 식별하기 위해, 태그 비트가 그러한 데이터 블록들과 연관하여 사용되는 방법을 개략적으로 예시한다. 특히, 메모리 어드레스 공간(110)은, 전형적으로 특정된 크기를 가질, 일련의 데이터 블록들(115)을 저장할 것이다. 순전히 예시를 위해, 이 예에서 각각의 데이터 블록이 128 비트를 포함하는 것으로 가정되지만, 다른 예시적인 구현예에서 상이한 크기의 데이터 블록, 예를 들어 캐퍼빌리티가 64 비트의 정보에 의해 정의될 때 64 비트 데이터 블록이 사용될 수 있다. 각각의 데이터 블록(115)과 연관하여, 태그 필드(120)가 제공되는데, 이는, 일례에서, 연관된 데이터 블록이 캐퍼빌리티를 표현한다는 것을 식별하도록 설정되는, 그리고 연관된 데이터 블록이 정상 데이터를 표현하고, 그에 따라 캐퍼빌리티로 취급될 수 없다는 것을 나타내도록 클리어되는, 태그 비트로 지칭되는 단일 비트 필드이다. 설정된 상태 또는 클리어 상태와 연관된 실제 값은 구현예에 따라 달라질 수 있지만, 순수하게 예시로서, 하나의 예시적인 구현예에서, 태그 비트가 1의 값을 갖는 경우, 그것은 연관된 데이터 블록이 캐퍼빌리티라는 것을 나타내고, 그것이 0의 값을 갖는 경우, 그것은 연관된 데이터 블록이 정상 데이터를 포함한다는 것을 나타낸다는 것이 이해될 것이다.

캐퍼빌리티가 도 3에 도시된 캐퍼빌리티 레지스터(100)와 같은 유계 포인터 레지스터들(60)(본 명세서에서 캐퍼빌리티 레지스터로도 지칭됨) 중 하나에 로딩될 때, 태그 비트는 캐퍼빌리티 정보와 함께 이동한다. 따라서, 캐퍼빌리티가 캐퍼빌리티 레지스터(100)에 로딩될 때, 포인터(102), 범위 정보(104), 및 제한 정보(106)(이하, 허가 정보로 지칭됨)가 캐퍼빌리티 레지스터에 로딩될 것이다. 추가적으로, 그러한 캐퍼빌리티 레지스터와 연관하여, 또는 그것 내의 특정 비트 필드로서, 콘텐츠들이 캐퍼빌리티를 표현한다는 것을 식별하도록 태그 비트(108)가 설정될 것이다. 유사하게, 캐퍼빌리티가 다시 메모리에 저장될 때, 캐퍼빌리티가 저장되는 데이터 블록과 연관하여 관련 태그 비트(120)가 설정될 것이다. 그러한 접근법에 의해, 캐퍼빌리티와 정상 데이터 간을 구별하고, 그에 따라, 정상 데이터가 캐퍼빌리티로서 사용될 수 없음을 보장하는 것이 가능하다.

도 1로 돌아가면, 장치는 특정 제어 정보를 저장하기 위한 하나 이상의 제어 레지스터들을 추가로 제공할 수 있다. 본 명세서에 설명된 기술들에 따르면, 장치는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여 캐퍼빌리티들/유계 포인터들을 생성할 수 있고, 하나의 예시적인 구현에서, 그 생성된 캐퍼빌리티에 대한 적합한 제약 정보를 결정할 때 제어 레지스터들 중 하나 이상을 참조할 수 있다.

캐퍼빌리티들은 다양한 형태들을 취할 수 있다. 도 4에 도시된 예에서, 캐퍼빌리티(100)는 포인터 값(102) 및 연관된 제약 정보를 포함한다. 이러한 예에서 제약 정보는 일부 범위 정보(104)(또한 본 명세서에서 한계 정보로 지칭됨)를 포함한다. 허가들의 세트는 또한 캐퍼빌리티의 제약 정보의 일부로서 제공될 수 있으며, 게다가 캐퍼빌리티는 (직접적으로 또는 그와 연관되어) 데이터의 대응하는 블록이 캐퍼빌리티로서 취급될지 여부를 식별하도록 설정 또는 클리어될 수 있는 앞서 설명된 태그 비트(108)를 포함할 수 있다.

캐퍼빌리티에 대해 특정된 허가들은 구현예에 따라 달라질 수 있지만, 하나의 예시적인 구현예에서 허가들은 그의 값이 캐퍼빌리티가 판독 액세스들에 대한 메모리 어드레스들을 생성하는 데 사용될 수 있는지를 나타내는 판독 허가 비트(130), 그의 값이 캐퍼빌리티가 기입 액세스들에 대한 메모리 어드레스들을 생성하는 데 사용될 수 있는지를 나타내는 기입 허가 비트(132), 및 그의 값이 캐퍼빌리티가 페치 및 실행될 명령어들의 메모리 어드레스들을 생성하는 데 사용될 수 있는지를 나타내는 실행 허가 비트(134)를 포함한다.

그러한 허가 정보는 캐퍼빌리티에 대한 메타데이터 정보로서 고려될 수 있다. 원하는 경우, 다른 메타데이터 정보(136)가 또한 캐퍼빌리티 내에서 식별될 수 있다. 순전히 예로서, 그러한 메타데이터는 캐퍼빌리티가 불변으로 고려되는지 여부를 나타낼 수 있다. 그러한 정보는 캐퍼빌리티 내의 추가 정보로서 직접 특정될 수 있지만, 그것은 몇몇 예시적인 구현예에서 캐퍼빌리티 내에 이미 제공된 다른 정보의 상태로부터 추론될 수 있다. 예를 들어, 하나의 특정 구현예에서, 실행 비트가 설정될 때, 명령어 실행으로부터 기인할 수 있는 포인터 값들의 정상 증분을 통하는 것을 제외하고는, 캐퍼빌리티에 의해 특정된 정보는 태그 비트를 클리어함(캐퍼빌리티를 효과적으로 무효화함)이 없이 수정될 수 없다는 점에서, 캐퍼빌리티는 불변인 것으로 간주된다.

포함될 수 있는 다른 메타데이터 정보(136)의 다른 예로서, 그러한 메타데이터는, 예를 들어, 처리 회로부가 그 캐퍼빌리티가 생성되었을 때 동작하고 있었던 동작 모드를 나타내기 위한 신뢰 표시의 레벨을 포함할 수 있다. 신뢰 레벨은 캐퍼빌리티(100)의 필드(136)에 직접 인코딩될 수 있거나, 대안적으로 신뢰 표시의 레벨은 신뢰 정보의 레벨을 포함하는 메모리 어드레스를 표시하는 데 사용되는 식별자를 제공할 수 있다. 그러한 식별자는 신뢰 정보의 레벨의 메모리 위치를 직접 나타낼 수 있거나, 그것은 예를 들어 신뢰 정보의 레벨을 포함하는 위치를 식별하기 위해 시스템 내의 글로벌 레지스터에 저장된 어드레스에 적용될 수 있는 오프셋을 특정할 수 있다.

도 5는, 프로그램 코드를 컴파일할 때, 메모리 내의 리터럴 풀(155)을 채우도록, 컴파일러(150)가 어떻게 배열될 수 있는지를 개략적으로 예시하는 도면이다. 특히, 처리 회로부 상에서 실행될 코드를 컴파일할 때, 컴파일러(150)는 다양한 상이한 리터럴 값들을 리터럴 풀(155) 내에 저장할 수 있다. 앞서 논의된 바와 같이, 본 명세서에 설명된 기술들 이전에, 그러한 컴파일러는 또한 리터럴 풀 내에 저장될 수 있는 다수의 컴파일러-생성 캐퍼빌리티들을 생성했을 수 있어서, 이어서, 그러한 캐퍼빌리티들은 코드의 실행 동안 처리 회로부에 의해 캐퍼빌리티 레지스터들에 로딩하기 위해 이용가능하다. 그러나, 앞서 언급된 바와 같이, 리터럴 풀 내의 그러한 컴파일러-생성 캐퍼빌리티들의 제공은 (컴파일된 코드 및 연관된 리터럴 풀로 이루어진) 전체 코드 크기를 상당히 증가시킬 수 있으며, 특히 비휘발성 저장소가 중요한 메모리 제약 디바이스들에서 전체 코드 크기를 감소시키는 것이 바람직할 것이다.

본 발명자들은, 컴파일러에 의해 전형적으로 생성될 수 있는 상당한 수의 캐퍼빌리티들이 단지 작은 데이터 구조들, 예를 들어, 글로벌 변수들, 주변기기들, 제어 레지스터들 등에 액세스하며, 따라서 이러한 캐퍼빌리티들에 대한 한계 정보를 표현하는 데 사용되는 제한된 수의 전형적인 크기들만이 존재함을 언급하였다. 추가로, 제한된 수의 가능한 허가 비트들의 조합들만이 전형적으로 그러한 캐퍼빌리티들에 사용된다는 점이 언급되었다. 본 명세서에 설명된 기술들에 따라, 이러한 캐퍼빌리티들에 대해, 컴파일러는, 컴파일 시간에 그러한 캐퍼빌리티들을 생성하지 않고, 대신에, 각각의 그러한 캐퍼빌리티에 대한 포인터 값을 결정하는 데 사용될 수 있는 리터럴 풀(155) 내에 리터럴 값을 저장하도록 배열될 수 있다. 전체 캐퍼빌리티보다는 그러한 리터럴 값의 저장은 리터럴 풀에 대한 크기 요건들을 상당히 감소시킬 수 있고, 따라서 전체 코드 크기를 감소시킬 수 있다.

추가로, 본 명세서에 설명된 기술들을 사용할 때, 처리 회로부는, 그러한 캐퍼빌리티들에 대한 신뢰를 손상시키지 않으면서, 리터럴 풀 내에 저장된 그러한 리터럴 값들을 사용하여 요구되는 캐퍼빌리티들을 생성하도록 적절한 시기에 배열될 수 있다. 특히, 캐퍼빌리티는, 리터럴 풀 내의(따라서 신뢰될 수 있는) 리터럴 값들 중 하나를 사용하는 특정 캐퍼빌리티 생성 명령어(명령어는 또한, 원하는 경우, 컴파일러에 의해 발행될 수 있음)를 실행함으로써 처리 회로부에 의해 적절한 시기에 생성될 수 있고, 그의 제약 정보는 명령어로부터 직접 유도될 수 있는(따라서 또한 신뢰될 수 있는) 정보를 사용하여 제한된 세트의 가능한 옵션들로부터 선택된다. 컴파일된 프로그램의 의도가 신뢰될 수 있기 때문에, 이러한 방식으로 생성된 캐퍼빌리티가 또한 신뢰될 수 있고, 따라서, 이러한 방식으로 생성된 캐퍼빌리티들은, 컴파일러 자체에 의해 생성되고 리터럴 풀 내에 저장된 캐퍼빌리티들만큼 높게 신뢰될 수 있다.

도 6은 하나의 예시적인 구현예에 따른, 장치 내에 제공될 수 있는 컴포넌트들을 예시하는 블록도이다. 이 예에서, 처리 회로부(200)는 명령어들의 시퀀스를 실행하기 위해 제공되며, 이러한 명령어들에 의해 특정된 데이터 처리 동작들의 수행 동안 처리 회로부는 범용 데이터 레지스터들(215), 범용 캐퍼빌리티 레지스터들(220) 및 프로그램 카운터 캐퍼빌리티 레지스터(225)에 액세스할 수 있다. 처리 회로부(200)는 다양한 형태들을 취할 수 있지만, 예를 들어, 도 1에 도시된 프로세서 파이프라인(4)의 형태를 취할 수 있다.

도 6에 도시된 예에서, 처리 회로부가 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 리터럴 풀(230) 내의 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 회로부(210)가 제공되고, 생성된 캐퍼빌리티의 포인터 값은 리터럴 값으로부터 결정된다. 이어서, 생성된 캐퍼빌리티에 대한 연관된 제약 정보는 캐퍼빌리티 생성 명령어에 의해 특정되는 정보에 따른 제한된 세트의 옵션들로부터 캐퍼빌리티 생성 회로부에 의해 선택된다. 이어서, 생성된 캐퍼빌리티는 캐퍼빌리티 생성 회로부(210)에 의해 식별된 목적지 캐퍼빌리티 레지스터(전형적으로, 식별된 목적지 레지스터는 캐퍼빌리티 생성 명령어에 의해 특정됨)에 기입될 수 있다. 이는, 예를 들어, 범용 캐퍼빌리티 레지스터들(220) 중 하나일 수 있지만, 일부 구현예들에서 또한, 일부 예시들에서, 프로그램 카운터 캐퍼빌리티 레지스터(225)일 수 있다.

캐퍼빌리티 생성 회로부(210)는 처리 회로부(200)에 대해 별개의 컴포넌트일 수 있지만, 도 6에 도시된 예에서, 캐퍼빌리티 생성 회로부(210)는 처리 회로부(200)에 의해 제공되는 것으로 간주된다.

도 6에 또한 도시된 바와 같이, 캐퍼빌리티 체크 회로부(205)는 또한, 별개의 컴포넌트로서 또는 도 6에 도시된 바와 같이 처리 회로부(200)의 일부로서 제공될 수 있다. 캐퍼빌리티 체크 회로부(205)는, 주어진 캐퍼빌리티를 사용하여 그의 메모리 어드레스가 생성되는 액세스 요청이 고려되고 있을 때, 주어진 캐퍼빌리티에 의해 식별된 제약 정보에 기초하여 그 액세스 요청이 허가되는지를 결정하기 위해 캐퍼빌리티 체크 동작을 수행하는 데 이용된다. 따라서, 캐퍼빌리티 체크는 예를 들어, 액세스가 진행되도록 허용되는지 여부를 결정하기 위해 캐퍼빌리티의 범위 및 허가 정보에 대한 참조를 수반할 수 있다. 캐퍼빌리티 체크의 실패의 경우에, 실패 표시가 처리 회로부에 제공될 수 있고, 이것은 다양한 형태들, 예를 들어 장애 신호를 취할 수 있다. 그러나, 캐퍼빌리티 체크가 통과되면, 액세스 요청이 메모리에 발행될 수 있다. 일부 구현예들에서, 예를 들어, 메모리 관리 유닛(MMU), 메모리 보호 유닛(MPU), 보안 속성 유닛(SAU), 또는 이들 컴포넌트들의 조합과 같은 컴포넌트들 내에서 액세스가 진행되도록 허용되기 전에, 하나 이상의 추가 체크들이 수행될 수 있다.

도 7은 캐퍼빌리티 생성 명령어가 처리 회로부(200)에 의해 실행될 때 캐퍼빌리티 생성 회로부(210)에 의해 수행되는 단계들을 예시하는 흐름도이다. 단계(250)에서, 캐퍼빌리티 생성 명령어가 실행되고 있다고 결정되면, 캐퍼빌리티들을 생성하는 능력을 제약할 수 있는 임의의 기준들을 고려하여, 캐퍼빌리티가 생성되도록 허용되는지 여부가 단계(255)에서 결정된다. 예로서, 캐퍼빌리티 생성 회로부(210)가 캐퍼빌리티 생성 명령어에 응답하여 캐퍼빌리티들을 생성하는 데 사용되는 본 명세서에 설명된 기술들은, 처리 회로부의 소정 동작 모드들로 제한될 수 있으며, 처리 회로부가 허용된 동작 모드들 중 하나 내에 있지 않으면, 단계(255)에서 캐퍼빌리티들이 생성될 수 없다고 결정될 수 있고, 그 경우, 단계(260)에서 결함이 제기될 수 있다. 다른 예로서, 캐퍼빌리티들을 생성하는 능력은 특정 유형들의 캐퍼빌리티들로 제한될 수 있다. 예를 들어, 일부 구현예들에서, 캐퍼빌리티가 프로그램 카운터 캐퍼빌리티로서 사용되려는 경우 전술된 메커니즘을 사용하여 그 캐퍼빌리티를 생성하는 것이 금지될 수 있고, 또한 이러한 상황들에서 프로그램 카운터 캐퍼빌리티를 생성하기 위한 시도가 존재하는 경우 단계(260)에서 결함이 제기될 수 있다.

그러나, 단계(255)에서, 캐퍼빌리티가 생성되도록 허용된다고 결정되는 것으로 가정하면, 단계(265)에서, 캐퍼빌리티 생성 명령어에 의해 특정된 즉치 값이 리터럴 풀 내의 위치를 식별하기 위해 현재 프로그램 카운터 값에 적용할 오프셋으로서 사용된다. 단계(270)에서, 그 식별된 위치의 리터럴 값이 리터럴 풀로부터 검색되고, 생성된 캐퍼빌리티에 대한 포인터 값을 결정하는 데 사용된다. 일부 경우들에서, 포인터 값을 형성하기 위해 전체 리터럴 값이 "있는 그대로" 사용될 수 있지만, 다른 구현예들에서, 검색된 리터럴 값으로부터 포인터 값을 유도하기 위한 단계들이 취해질 수 있다. 특정 예로서, 포인터 값의 일부 정렬 요건들이 생성되는 것으로 인해, 포인터 값을 생성하는 목적들을 위해 리터럴 값의 소정 수의 최하위 비트들이 무시될 수 있다. 나중에 더 상세히 논의될 바와 같이, 이러한 무시된 최하위 비트들은, 원하는 경우, 일부 예시적인 구현예들에서 캐퍼빌리티를 생성하는 데 사용되는 다른 정보를 제공하도록 용도 변경될 수 있다.

단계(275)에서, 생성되는 캐퍼빌리티에 대한 한계 정보는 명령어에 의해 제공된 정보로부터 유도된 크기 정보로부터 결정될 수 있다. 특히, 명령어에 의해 제공되는 정보는 제한된 세트의 가능한 크기들 내에서 크기를 인코딩하는 데 사용될 수 있고, 따라서 캐퍼빌리티 생성 회로부는 이러한 정보에 기초하여 한계들에 대해 어느 크기를 사용할지를 결정할 수 있다. 이어서, 제1 한계는, 예를 들어, 그 포인터 값과 동일하게 설정됨으로써, 단계(270)에서 식별된 포인터 값을 참조하여 결정될 수 있다. 이어서, 제2 한계를 생성하기 위해, 결정된 크기를 제1 한계에 적용함으로써, 제2 한계가 결정될 수 있다.

단계(280)에서 표시된 바와 같이, 명령어에 의해 특정된 정보로부터, 다른 메타데이터, 예를 들어, 앞서 언급된 허가 비트들이 결정될 수 있다. 또한, 제한된 세트의 가능한 값들이 이용가능하며, 따라서 명령어에 의해 제공되는 정보는, 제한된 세트의 가능한 값들로부터의 값들의 어느 조합을 사용할지를 결정하는 데 사용될 수 있다.

캐퍼빌리티 생성 명령어는 다양한 형태들을 취할 수 있지만, 하나의 특정 예에서, 다음의 포맷을 갖는다:

LDRCC Cd, <label>, #sz

따라서, 이 예에서, 캐퍼빌리티 생성 명령어는, 목적지 캐퍼빌리티 레지스터(Cd)를 특정하고, 리터럴 풀 내의 위치를 식별하는 데 사용되는 즉치 값("라벨"로 지칭됨)을 제공하고, 생성된 캐퍼빌리티에 대한 허용가능한 범위의 크기를 결정하는 데 사용되는 크기 정보(#sz)를 특정하는 캐퍼빌리티 생성 부하 명령어이다. 그러나, 이는 사용될 수 있는 단지 하나의 예시적인 포맷이며, 캐퍼빌리티를 생성하기 위해 요구되는 정보가 리터럴 풀로부터 검색된 리터럴 값과 조합하여 명령어 자체로부터 유도될 수 있다면, 다른 포맷들이 사용될 수 있다.

도 8은 생성된 캐퍼빌리티에 대한 한계들을 결정하기 위해 도 7의 단계(275)에서 구현될 수 있는 단계들을 더 상세히 예시하는 흐름도이다. 단계(300)에서, 예를 들어, 위에서 언급된 LDRCC 명령어 포맷의 경우와 같이, 크기 표시 값이 명령어에서 직접 특정되는지 여부가 결정된다. 크기 표시 값이 특정되면, 프로세스는 특정된 크기 표시로부터 크기가 결정되는 단계(305)로 진행한다. 크기 표시 값은 크기를 직접 특정할 수 있거나, 또는 크기를 식별하기 위해 적합한 인코딩 방식을 사용할 수 있다. 예를 들어, 제한된 세트의 옵션들 내의 크기들은 2의 거듭제곱만큼 변할 수 있고, 크기 표시는 적용할 2의 거듭제곱을 나타낼 수 있다. 대안적으로, 크기 표시는 미리 결정된 최소 크기 표시로부터의 오프셋을 특정할 수 있다. 크기 표시가 어떻게 형성되는지와 무관하게, 단계(305)에서, 캐퍼빌리티 생성 회로부(210)가 크기 표시로부터 캐퍼빌리티와 연관된 영역의 크기를 결정할 수 있다는 것이 인식될 것이다.

대안적인 구현에서, 크기 표시 값은 명령어에서 직접 특정되지 않을 수 있고, 대신에 도 8에 예시된 바와 같이, 단계(310)에 의해 표시된 바와 같이, 메모리로부터 검색된 리터럴 값의 중복 비트들로부터 크기를 결정하는 것이 가능할 수 있다. 특히, 앞서 언급된 바와 같이, 포인터 값에 대한 일부 정렬 제약들로 인해, 그렇지 않으면 사용되지 않는 리터럴 값 내에 비트들이 존재할 수 있고, 이러한 비트들은 다수의 가능한 사용들을 위해 용도 변경될 수 있으며, 이들 중 하나는 크기 정보를 인코딩하는 것이다. 그 정보는, 크기 표시가 명령어에서 직접 특정된 것과 거의 동일한 방식으로 리터럴 값의 중복 비트들 내에서 인코딩될 수 있고, 따라서 단계(305)를 참조하여 앞서 논의된 형태들 중 임의의 형태를 취할 수 있다.

또 다른 추가의 대안으로서, 도 8에 구체적으로 예시되지는 않았지만, 크기가 고정되고, 따라서 크기 표시 값이 특정될 필요가 없는 경우일 수 있다. 대신에, 한계들은, 제1 한계를 식별한 다음, 고정된 크기를 적용하여 제1 한계로부터 제2 한계의 위치를 결정함으로써 직접 결정될 수 있다.

이어서, 단계들(305 또는 310) 중 어느 단계가 수행되는지와 무관하게, 프로세스는 포인터 값으로부터 제1 한계가 결정되는 단계(315)로 진행한다. 포인터 값으로부터 한계를 결정하기 위해 임의의 적합한 기술이 사용될 수 있으며, 따라서, 예를 들어, 제1 한계는 포인터 값으로부터 일부 고정된 오프셋에 있을 수 있다. 그러나, 하나의 특정 예시적인 구현예에서, 제1 한계는 포인터 값과 동일하게 설정된다.

이어서, 단계(320)에서, 제1 한계 및 결정된 크기로부터 제2 한계가 결정된다. 예로서, 제2 한계는 포인터 값 플러스 결정된 크기와 동일하게 설정될 수 있다. 일단 제1 한계 및 제2 한계가 설정되면, 그 지점에서 캐퍼빌리티에 대한 범위 정보가 결정되었다고 인식될 것이다.

도 9는 허가 비트 값들이 결정될 수 있는 다양한 상이한 방식들을 예시하는 흐름도이다. 동일한 유형의 접근법이 또한 캐퍼빌리티의 제약 정보의 일부로서 제공될 수 있는 임의의 다른 메타데이터에 대해 사용될 수 있다. 단계(350)에서, 허가들이 명령어 내의 즉치 피연산자에 의해 특정되는지 여부가 결정된다. 예를 들어, 허가 비트 값들은, 원하는 경우, 그러한 즉치 피연산자에 의해 명령어 내에서 직접 특정될 수 있다. 대안적으로, 즉치 피연산자의 값은 가능한 제한된 세트의 허가 조합들의 중 어느 것이 사용될지를 결정하는 데 사용될 수 있는 방식으로 인코딩될 수 있으며, 이는 즉치 피연산자에 의해 허가들이 직접 특정되는 경우보다 명령어 내에 더 적은 비트 공간을 요구할 수 있다.

허가들이 즉치 피연산자에 의해 특정되면, 프로세스는 단계(355)로 진행하고, 여기서 캐퍼빌리티 생성 회로부(210)는 그 즉치 피연산자로부터 허가들을 결정한다.

단계(350)에서, 허가들이 명령어 내의 즉치 피연산자에 의해 특정되지 않는다고 결정되면, 단계(360)에서, 허가 정보를 제공하기 위해 제어 레지스터가 사용되어야 하는지 여부가 결정된다. 특히, 하나의 예시적인 구현예에서, 적어도 일부 생성된 캐퍼빌리티들에 대해, 요구되는 허가 정보는 하나 이상의 제어 레지스터들(90) 내에 저장될 수 있다. 허가 정보에 대해 제어 레지스터가 참조되어야 한다고 결정되면, 프로세스는 단계(365)로 진행하여, 제어 레지스터 내의 허가 정보로부터 허가들이 결정된다. 명령어 내의 즉치 피연산자와 같이, 제어 레지스터 내의 그러한 정보는 허가 정보를 직접 식별할 수 있거나, 또는 대안적으로, 제한된 세트의 허가들의 조합들 중 어느 것이 사용될지를 식별하는 데 사용되는 인코딩을 제공할 수 있다.

단계(360)에서, 제어 레지스터가 허가 정보를 제공하는 데 사용되지 않을 것으로 결정되면, 단계(370)에서, 리터럴 풀로부터 검색된 리터럴 값의 중복 비트들로부터 허가 정보가 획득되고, 이어서 그 허가 정보로부터 허가들이 결정된다. 따라서, 일부 예시들에서, 즉치 피연산자를 특정하거나 또는 제어 레지스터로부터 허가 정보를 얻는 것보다, 그 허가 정보는 포인터 값을 형성하도록 요구되지 않는 리터럴 값의 중복 비트들 내에서 인코딩될 수 있다. 앞서 설명된 예들에서와 같이, 허가 값들은 그러한 비트들 내에서 직접 특정될 수 있거나, 또는 그러한 비트들은 승인 비트들의 가능한 조합들 중 어느 것이 사용될지를 결정하는 데 사용되는 인코딩을 제공할 수 있다.

도 9에 표시된 바와 같이, 어떤 메커니즘이 사용되는지에 무관하게, 제한된 세트의 옵션들로부터 허가들의 적합한 조합이 결정될 수 있는 인코딩을 허가 정보가 제공하는 상황들에서, 결정된 허가들은 캐퍼빌리티가 생성된 시간에 처리 회로부의 동작 모드에 의존할 수 있다. 예를 들어, 처리 회로부가 특정 특권화된 동작 모드에서 동작하고 있는 경우, 허가 정보의 특정 값으로부터 결정된 허가 비트들은, 처리 회로부가 덜 특권화된 모드에서 동작하고 있었다면 결정되었을 허가 비트들과 상이할 수 있다. 추가로, 허가 정보로부터 결정된 허가 비트들은 생성되는 캐퍼빌리티의 유형에 의존할 수 있고, 따라서, 예를 들어, 결정된 허가 비트들은 범용 캐퍼빌리티가 생성되고 있는지 또는 프로그램 카운터 캐퍼빌리티가 생성되고 있는지에 따라 상이할 수 있다.

도 10은 시스템 내에 제공될 수 있는 처리 회로부의 다양한 상이한 동작 모드들을 예시하는 도면이다. 도 10에 도시된 바와 같이, 처리 회로부는 보안 도메인 및 하위 보안 도메인에서 동작하도록 배열될 수 있다. 추가로 또는 대안적으로, 처리 회로부는 복수의 상이한 상태에서 프로그램 코드를 실행하도록 배열될 수 있으며, 도 10의 예에서 프로그램 코드를 특권화된 상태 또는 비특권화된 상태에서 실행하도록 배열될 수 있다. 특권 레벨들 및 상이한 보안 도메인들은 신뢰의 직교 레벨들인 것으로서 보여질 수 있으며, 따라서 도메인 및 상태의 상이한 조합들은 처리 회로부의 상이한 동작 모드들을 정의하는 데 사용될 수 있다. 앞서 논의된 바와 같이, 생성된 캐퍼빌리티에 대한 제약 정보가 결정되는 방식은 처리 회로부가 어느 동작 모드에 있는지에 의존할 수 있다. 추가로, 원하는 경우, 본 명세서에서 설명된 기술들을 사용하여 캐퍼빌리티들을 생성하는 능력은 동작 모드들 중 하나 이상으로 제한될 수 있으며, 예를 들어, 비인가된 동작 모드들 중 하나에서 캐퍼빌리티를 생성하려는 시도가 이루어진 경우 결함이 생성된다.

도 11은 하나의 예시적인 구현에서, 캐퍼빌리티를 생성할 때 취해진 단계들이, 생성되는 캐퍼빌리티가 프로그램 카운터 캐퍼빌리티인지 또는 범용 캐퍼빌리티인지에 어떻게 의존할 수 있는지를 예시하는 흐름도이다. 단계(400)에서, 캐퍼빌리티 생성 명령어에 의해 특정된 목적지 캐퍼빌리티 레지스터가 프로그램 카운터 캐퍼빌리티 레지스터인지 여부가 결정된다. 그렇지 않은 경우, 프로세스는 단계(405)로 진행하고, 여기서 캐퍼빌리티는 앞서 논의된 방식으로 생성되고, 명령어에 의해 식별된 타겟 범용 캐퍼빌리티 레지스터 내에 저장된다.

그러나, 하나의 예시적인 구현에서, 목적지 캐퍼빌리티 레지스터가 프로그램 카운터 캐퍼빌리티 레지스터이면, 단계(410)에서, 전술된 방식으로 캐퍼빌리티를 생성하고 생성된 캐퍼빌리티를 프로그램 카운터 캐퍼빌리티 레지스터에 저장하는 것 외에도, 추가적인 단계(415)가 또한 수행되어, 생성된 프로그램 카운터 캐퍼빌리티를 사용하여 식별된 타겟 명령어로 분기하기 위한 프로그램 실행이 또한 야기된다. 이는, 프로그램 카운터 캐퍼빌리티의 생성에 후속하여 그 타겟 명령어로 분기하기 위해 별개의 분기 명령어를 제공할 필요성을 피한다.

원하는 경우, 캐퍼빌리티 생성 회로부(210)는 도 12에 예시된 바와 같이, 단일 캐퍼빌리티 생성 명령어의 실행에 응답하여 다수의 캐퍼빌리티들을 생성하도록 배열될 수 있다. 예를 들어, 캐퍼빌리티 생성 명령어가 실행될 때 다수의 캐퍼빌리티들이 생성되어야 함을 식별하는 캐퍼빌리티 생성 명령어의 유형이 특정될 수 있다. 그러한 인스턴스에서, 그 특정 형태의 캐퍼빌리티 생성 명령어가 실행되고 있다고 단계(450)에서 결정될 때, 프로세스는 단계(455)로 진행하며, 여기서, 도 7의 앞서 설명된 프로세스를 사용하여 제1 캐퍼빌리티가 생성된다. 이어서, 단계(460)에서, 각각의 후속 캐퍼빌리티는 제1 캐퍼빌리티에 대한 리터럴 값을 획득하기 위해 사용된 위치로부터 오프셋된 위치로부터 획득된 리터럴 값을 사용하여 생성된다. 각각의 후속 캐퍼빌리티에 대한 리터럴 값을 식별하는 데 사용될 오프셋은 예를 들어, 리터럴 풀 내에 저장된 일련의 인접한 리터럴 값들을 식별하기 위해 미리 결정될 수 있거나, 또는 대안적으로, 각각의 후속 캐퍼빌리티에 대한 리터럴 값들을 식별하는 데 요구되는 오프셋 정보는 명령어 내에서 일부 포맷으로 인코딩될 수 있다.

도 12에 도시된 예에 따르면, 단계(460)에서 표시된 바와 같이, 생성된 캐퍼빌리티들 각각에 대해 동일한 제약 정보가 사용되고, 따라서 단일 캐퍼빌리티 생성 명령어로부터 생성된 캐퍼빌리티들 사이에 차이가 없다.

단계(465)에서, 생성된 캐퍼빌리티들은 범용 캐퍼빌리티 레지스터들의 시퀀스에 저장된다. 전형적으로, 제1 범용 캐퍼빌리티 레지스터는 캐퍼빌리티 생성 명령어에 의해 명시적으로 식별되는 것이 될 것이며, 이어서, 추가적인 범용 캐퍼빌리티 레지스터들 각각이 추론될 수 있다. 예를 들어, 각각의 후속 범용 캐퍼빌리티는 결정된 시퀀스를 따를 수 있다. 예를 들어, 캐퍼빌리티 생성 명령어에 의해 특정된 캐퍼빌리티 레지스터로 시작하는 일련의 인접한 범용 캐퍼빌리티 레지스터들은, 생성된 캐퍼빌리티들이 저장되는 범용 캐퍼빌리티 레지스터들의 시퀀스로서 사용될 수 있다. 대안적으로, 일부 시퀀스 정의 정보는 명령어 내에 제공될 수 있고, 생성된 캐퍼빌리티들이 저장되어야 하는 각각의 범용 캐퍼빌리티 레지스터를 식별하는 데 사용될 수 있다. 또 추가적인 예로서, 명령어는 각각의 범용 목적지 캐퍼빌리티 레지스터를 명시적으로 식별할 수 있다.

도 13은 사용될 수 있는 시뮬레이터 구현예를 예시한다. 앞서 설명된 예들은 관심이 있는 기술들을 지원하는 특정 처리 하드웨어를 동작시키기 위한 장치 및 방법들과 관련하여 본 발명을 구현하지만, 본 명세서에서 설명되는 예들에 따라 컴퓨터 프로그램의 사용을 통해 구현되는 명령어 실행 환경을 제공하는 것이 또한 가능하다. 그러한 컴퓨터 프로그램들은, 그들이 하드웨어 아키텍처의 소프트웨어 기반 구현예를 제공하는 한, 종종 시뮬레이터들로 지칭된다. 다양한 시뮬레이터 컴퓨터 프로그램들은 에뮬레이터들, 가상 머신들, 모델들, 및 동적 이진 변환기(dynamic binary translator)들을 포함한 이진 변환기들을 포함한다. 전형적으로, 시뮬레이터 구현예는 호스트 프로세서(515) 상에서 실행되어, 호스트 운영 체제(510)를 선택적으로 실행하여, 시뮬레이터 프로그램(505)을 지원할 수 있다. 몇몇 배열들에서, 하드웨어와 제공된 명령어 실행 환경 사이에 다수의 시뮬레이션 계층들이 있을 수 있고/있거나, 동일한 호스트 프로세서 상에 제공된 다수의 별개의 명령어 실행 환경들이 있을 수 있다. 이력상, 강력한 프로세서들이 합리적인 속도로 실행되는 시뮬레이터 구현예들을 제공하는 데 요구되었지만, 그러한 접근법은 호환성 또는 재사용 이유들을 위해 다른 프로세서에 고유한 코드를 실행하려는 요구가 있을 때와 같은 소정 상황들에서 정당화될 수 있다. 예를 들어, 시뮬레이터 구현예는 호스트 프로세서 하드웨어에 의해 지원되지 않는 추가적인 기능을 명령어 실행 환경에 제공할 수 있거나, 또는 상이한 하드웨어 아키텍처와 전형적으로 연관된 명령어 실행 환경을 제공할 수 있다. 시뮬레이션의 개요가 문헌["Some Efficient Architecture Simulation Techniques", Robert Bedichek, Winter 1990, USENIX Conference, Pages 53 to 63]에서 주어진다.

예들이 특정 하드웨어 구성들 또는 특징부들을 참조하여 전술되었음을 고려한 결과로, 시뮬레이션된 구현예에서, 동등한 기능이 적합한 소프트웨어 구성들 또는 특징부들에 의해 제공될 수 있다. 예를 들어, 특정 회로부가 시뮬레이션된 구현예에서 컴퓨터 프로그램 로직으로서 제공될 수 있다. 유사하게, 레지스터 또는 캐시와 같은 메모리 하드웨어가 시뮬레이션된 구현예에서 소프트웨어 데이터 구조로서 구현될 수 있다. 또한, 하드웨어 장치(2) 내의 메모리(50)에 액세스하는 데 사용되는 물리 어드레스 공간은 시뮬레이터(505)에 의한 호스트 운영 체제(510)에 의해 사용되는 가상 어드레스 공간에 매핑되는 시뮬레이션된 어드레스 공간으로서 에뮬레이팅될 수 있다. 전술된 예들에서 언급된 하드웨어 요소들 중 하나 이상의 하드웨어 요소들이 호스트 하드웨어(예를 들어, 호스트 프로세서(515)) 상에 존재하는 배열들에서, 몇몇 시뮬레이션된 구현예들은, 적합한 경우, 호스트 하드웨어를 사용할 수 있다.

시뮬레이터 프로그램(505)은 컴퓨터 판독가능 저장 매체(이는 비일시적 매체일 수 있음) 상에 저장될 수 있고, 타겟 코드(500)(이는 애플리케이션들, 운영 체제들, 및 하이퍼바이저를 포함할 수 있음)에 가상 하드웨어 인터페이스(명령어 실행 환경)를 제공하는데, 이는 시뮬레이터 프로그램(505)에 의해 모델링되는 하드웨어 아키텍처의 하드웨어 인터페이스와 동일하다. 따라서, 타겟 코드(500)의 프로그램 명령어들은 시뮬레이터 프로그램(505)을 사용하여 명령어 실행 환경 내로부터 실행되어, 위에서 논의된 장치(2)의 하드웨어 특징부들을 실제로 갖지 않는 호스트 컴퓨터(515)가 그러한 특징부들을 에뮬레이팅할 수 있게 할 수 있다. 시뮬레이터 프로그램은 처리 파이프라인(4, 200)의 거동을 에뮬레이팅하기 위한 처리 프로그램 로직(520), 캐퍼빌리티 체크 회로부(205)의 거동을 에뮬레이팅하기 위한 캐퍼빌리티 체크 프로그램 로직(522), 및 도 1 및 도 6의 하드웨어 장치의 캐퍼빌리티 생성 회로부(210)의 거동을 에뮬레이팅하기 위한 캐퍼빌리티 생성 프로그램 로직(525)을 포함할 수 있다. 따라서, 앞서 논의된 유형의 캐퍼빌리티 생성 명령어들에 응답하여 캐퍼빌리티들을 생성하기 위해 본 명세서에 설명된 기술들은 도 13의 예에서 시뮬레이터 프로그램(505)에 의해 소프트웨어로 수행될 수 있다.

본 출원에서, "...하도록 구성된"이라는 단어들은 장치의 요소가 정의된 동작을 수행할 수 있는 구성을 갖는다는 것을 의미하는 데 사용된다. 이러한 문맥에서, "구성"은 하드웨어 또는 소프트웨어의 상호접속의 배열 또는 방식을 의미한다. 예를 들어, 장치는 정의된 동작을 제공하는 전용 하드웨어를 가질 수 있거나, 프로세서 또는 다른 처리 디바이스가 기능을 수행하도록 프로그래밍될 수 있다. "하도록 구성된"은, 장치 요소가, 정의된 동작을 제공하기 위해 어떤 방식으로든 변경될 필요가 있음을 암시하지는 않는다.

본 발명의 예시적인 실시예 구현예들이 첨부 도면들을 참조하여 본 명세서에서 상세히 설명되었지만, 본 발명은 그러한 정확한 구현예들로 제한되지 않으며, 첨부된 청구항들에 의해 한정된 바와 같은 본 발명의 범위 및 사상으로부터 벗어남이 없이 실시예들에서 다양한 변경들, 추가들 및 수정들이 당업자에 의해 이루어질 수 있다는 것이 이해되어야 한다. 예를 들어, 본 발명의 범주로부터 벗어남이 없이 독립 청구항의 특징과 종속 청구항의 특징의 다양한 조합이 이루어질 수 있다.

Claims (24)

1. 장치로서,
   메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하는 처리 회로부 - 상기 처리 회로부는 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티(capability)들을 사용하여 상기 액세스 요청들에 대한 메모리 어드레스들을 생성하도록 배열됨 -; 및
   상기 처리 회로부가 상기 메모리의 리터럴 풀(literal pool) 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 상기 리터럴 풀 내의 상기 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 회로부를 포함하고, 상기 생성된 캐퍼빌리티의 상기 포인터 값은 상기 리터럴 값으로부터 결정되고, 상기 생성된 캐퍼빌리티의 상기 제약 정보는 상기 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택되는, 장치.
2. 제1항에 있어서, 상기 캐퍼빌리티 생성 명령어는, 상기 생성된 캐퍼빌리티의 상기 포인터 값을 결정하는 데 사용될 상기 리터럴 값을 포함하는 상기 리터럴 풀 내의 위치를 식별하기 위해, 현재 프로그램 카운터 값과 조합하여, 상기 캐퍼빌리티 생성 회로부에 의해 사용되는 즉치 값(immediate value)을 특정하는, 장치.
3. 제1항 또는 제2항에 있어서, 상기 제약 정보는 상기 생성된 캐퍼빌리티의 상기 포인터 값으로부터 유도된 메모리 어드레스들을 사용하여 액세스가능한 메모리의 영역을 식별하는 한계 정보를 포함하고, 상기 제한된 세트의 옵션들은 상기 한계 정보에 의해 식별된 영역의 제한된 세트의 허용가능한 크기들을 포함하는, 장치.
4. 제3항에 있어서, 상기 캐퍼빌리티 생성 명령어는, 상기 제한된 세트의 허용가능한 크기들로부터 상기 영역의 크기를 결정하기 위해 상기 캐퍼빌리티 생성 회로부에 의해 사용되는 크기 표시 값을 특정하는, 장치.
5. 제3항에 있어서, 상기 리터럴 값은 상기 포인터 값을 결정하는 데 사용되지 않는 다수의 중복 비트들을 포함하고, 상기 캐퍼빌리티 생성 회로부는 상기 리터럴 값의 상기 중복 비트들 내에서 제공된 정보로부터 상기 영역의 크기를 결정하도록 배열되는, 장치.
6. 제5항에 있어서, 상기 캐퍼빌리티 생성 회로부는, 상기 리터럴 값을 형성하는 데 사용되는 인코딩 방식에 따라, 상기 포인터 값을 결정하는 데 사용되는 비트들을 특정하는 제1 부분과 상기 중복 비트들을 포함하는 제2 부분 사이의 상기 리터럴 값 내의 경계를 결정하도록 배열되는, 장치.
7. 제3항 내지 제6항 중 어느 한 항에 있어서, 상기 한계 정보는 상기 포인터 값으로부터 결정된 제1 한계, 및 상기 제1 한계로부터 결정된 제2 한계 및 상기 제한된 세트의 허용가능한 크기들로부터 결정된 상기 영역의 크기를 식별하는, 장치.
8. 제1항 내지 제7항 중 어느 한 항에 있어서, 상기 제약 정보는 메타데이터의 항목들을 포함하고, 상기 제한된 세트의 옵션들은 상기 메타데이터의 항목들에 대한 제한된 세트의 가능한 값들을 포함하는, 장치.
9. 제8항에 있어서, 상기 캐퍼빌리티 생성 명령어는 상기 메타데이터의 항목들 중 하나 이상에 대한 값들을 결정하기 위해 상기 캐퍼빌리티 생성 회로부에 의해 사용되는 메타데이터 정보를 특정하는, 장치.
10. 제8항 또는 제9항에 있어서, 상기 메타데이터의 항목들 중 하나 이상에 대한 값들을 결정하기 위해 상기 캐퍼빌리티 생성 회로부에 의해 참조되는 제어 레지스터를 더 포함하는, 장치.
11. 제8항 내지 제10항 중 어느 한 항에 있어서, 상기 리터럴 값은 상기 포인터 값을 결정하는 데 사용되지 않는 다수의 중복 비트들을 포함하고, 상기 처리 회로부는, 상기 리터럴 값의 상기 중복 비트들 내에서 제공된 정보로부터 상기 메타데이터의 항목들 중 하나 이상에 대한 값들을 결정하도록 배열되는, 장치.
12. 제9항 내지 제11항 중 어느 한 항에 있어서, 상기 메타데이터의 항목들 중 하나 이상에 대한 결정된 값들은 상기 처리 회로부의 현재 동작 모드에 의존하는, 장치.
13. 제8항 내지 제12항 중 어느 한 항에 있어서, 상기 메타데이터의 항목들은 상기 생성된 캐퍼빌리티의 허용가능한 사용들을 식별하는 복수의 허가 표시들을 포함하고, 상기 제한된 세트의 옵션들은 상기 복수의 허가 표시들에 의해 표시될 수 있는 허가들의 제한된 세트의 허용된 조합들을 포함하는, 장치.
14. 제13항에 있어서, 상기 캐퍼빌리티 생성 회로부는 상기 생성된 캐퍼빌리티의 유형에 따라 상기 복수의 허가 표시들에 의해 나타내기 위한 허가들의 조합을 결정하도록 배열되는, 장치.
15. 제14항에 있어서, 상기 캐퍼빌리티 생성 명령어는 목적지 캐퍼빌리티 저장 요소를 특정하고, 상기 캐퍼빌리티 생성 회로부는 상기 특정된 목적지 캐퍼빌리티 저장 요소로부터 상기 생성된 캐퍼빌리티의 유형을 추론하도록 배열되는, 장치.
16. 제1항 내지 제15항 중 어느 한 항에 있어서,
    상기 캐퍼빌리티 생성 명령어는 목적지 캐퍼빌리티 저장 요소를 특정하고;
    상기 특정된 목적지 캐퍼빌리티 저장 요소가 프로그램 카운터 캐퍼빌리티를 저장하는 데 사용되는 프로그램 카운터 캐퍼빌리티 저장 요소일 때, 상기 처리 회로부는, 상기 생성된 캐퍼빌리티가 상기 프로그램 카운터 캐퍼빌리티 저장 요소에 저장되면, 프로그램 실행을 상기 생성된 캐퍼빌리티를 사용하여 식별된 타겟 분기로 분기하게 하도록 배열되는, 장치.
17. 제1항 내지 제15항 중 어느 한 항에 있어서,
    상기 캐퍼빌리티 생성 명령어는 목적지 캐퍼빌리티 저장 요소를 특정하고;
    상기 캐퍼빌리티 생성 회로부는, 상기 특정된 목적지 캐퍼빌리티 저장 요소가 프로그램 카운터 캐퍼빌리티 저장 요소인 경우 결함을 트리거하도록 배열되는, 장치.
18. 제1항 내지 제17항 중 어느 한 항에 있어서,
    상기 캐퍼빌리티 생성 회로부는, 상기 처리 회로부가 상기 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 상기 생성된 캐퍼빌리티 및 하나 이상의 추가로 생성된 캐퍼빌리티들을 도출하도록 배열되고, 각각의 추가로 생성된 캐퍼빌리티에 대해, 상기 캐퍼빌리티 생성 회로부는 상기 캐퍼빌리티 생성 명령어에 의해 식별된 위치로부터 오프셋되는, 상기 리터럴 풀 내의 연관된 위치로부터 획득된 연관된 리터럴 값으로부터 상기 추가로 생성된 캐퍼빌리티에 대한 포인터 값을 결정하도록 배열되는, 장치.
19. 제18항에 있어서, 상기 캐퍼빌리티 생성 회로부는 상기 생성된 캐퍼빌리티 및 동일한 제약 정보를 갖는 각각의 추가로 생성된 캐퍼빌리티를 도출하도록 배열되는, 장치.
20. 제18항 또는 제19항에 있어서, 상기 캐퍼빌리티 생성 명령은 상기 생성된 캐퍼빌리티에 대한 목적지 캐퍼빌리티 저장 요소를 특정하고, 상기 캐퍼빌리티 생성 회로부는 상기 특정된 목적지 캐퍼빌리티 저장 요소로부터, 각각의 추가로 생성된 캐퍼빌리티에 대한 연관된 목적지 캐퍼빌리티 저장 요소를 도출하도록 배열되는, 장치.
21. 제1항 내지 제20항 중 어느 한 항에 있어서, 상기 처리 회로부는 다수의 상이한 동작 모드들에서 동작가능하고, 상기 캐퍼빌리티 생성 회로부의 동작은 상기 처리 회로부의 현재 동작 모드에 의존하는, 장치.
22. 제1항 내지 제21항 중 어느 한 항에 있어서,
    주어진 캐퍼빌리티를 사용하여 메모리 어드레스가 생성되는 주어진 액세스 요청이 상기 주어진 캐퍼빌리티에 의해 제공된 제약 정보에 기초하여 허가되는지 여부를 결정하기 위해 캐퍼빌리티 체크 동작을 수행하는 캐퍼빌리티 체크 회로부를 더 포함하는, 장치.
23. 메모리에 대한 액세스를 제약하는 방법으로서,
    메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하는 처리 회로부를 이용하는 단계 - 상기 처리 회로부는 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 상기 액세스 요청들에 대한 메모리 어드레스들을 생성함 -; 및
    상기 처리 회로부가 상기 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 상기 메모리의 리터럴 풀 내의 상기 위치로부터 리터럴 값을 검색하는 것 및 생성된 캐퍼빌리티를 도출하는 것을 포함하는 캐퍼빌리티 생성 동작을 수행하는 단계를 포함하고, 상기 생성된 캐퍼빌리티의 상기 포인터 값은 상기 리터럴 값으로부터 결정되고, 상기 생성된 캐퍼빌리티의 상기 제약 정보는 상기 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택되는, 방법.
24. 명령어 실행 환경을 제공하도록 호스트 데이터 처리 장치를 제어하기 위한 컴퓨터 프로그램으로서,
    메모리에 대한 액세스 요청들이 생성되는 동작들을 수행하는 처리 프로그램 로직 - 상기 처리 프로그램 로직은 포인터 값 및 연관된 제약 정보를 제공하는 캐퍼빌리티들을 사용하여 상기 액세스 요청들에 대한 메모리 어드레스들을 생성하도록 배열됨 -; 및
    상기 처리 프로그램 로직이 상기 메모리의 리터럴 풀 내의 위치를 식별하는 캐퍼빌리티 생성 명령어를 실행하는 것에 응답하여, 상기 리터럴 풀 내의 상기 위치로부터 리터럴 값을 검색하고, 생성된 캐퍼빌리티를 도출하는 캐퍼빌리티 생성 프로그램 로직을 포함하고, 상기 생성된 캐퍼빌리티의 상기 포인터 값은 상기 리터럴 값으로부터 결정되고, 상기 생성된 캐퍼빌리티의 상기 제약 정보는 상기 캐퍼빌리티 생성 명령어에 의해 특정된 정보에 따른 제한된 세트의 옵션들로부터 선택되는, 컴퓨터 프로그램.

Images